forgeframe 0.0.1

package/dist/forgeframe.js

@@ -0,0 +1,3179 @@
+const p = {
+  /** Render component in an iframe */
+  IFRAME: "iframe",
+  /** Render component in a popup window */
+  POPUP: "popup"
+}, f = {
+  /** Emitted when rendering starts */
+  RENDER: "render",
+  /** Emitted when component is fully rendered and initialized */
+  RENDERED: "rendered",
+  /** Emitted when prerender (loading) phase starts */
+  PRERENDER: "prerender",
+  /** Emitted when prerender phase completes */
+  PRERENDERED: "prerendered",
+  /** Emitted when component becomes visible */
+  DISPLAY: "display",
+  /** Emitted when an error occurs */
+  ERROR: "error",
+  /** Emitted when component is closing */
+  CLOSE: "close",
+  /** Emitted when component is destroyed */
+  DESTROY: "destroy",
+  /** Emitted when props are updated */
+  PROPS: "props",
+  /** Emitted when component is resized */
+  RESIZE: "resize",
+  /** Emitted when component receives focus */
+  FOCUS: "focus"
+}, I = {
+  /** Default JSON serialization */
+  JSON: "json",
+  /** Base64 encoding for binary or large data */
+  BASE64: "base64",
+  /** Dot notation for nested objects (e.g., "a.b.c=value") */
+  DOTIFY: "dotify"
+}, D = {
+  /** Request message expecting a response */
+  REQUEST: "request",
+  /** Response to a previous request */
+  RESPONSE: "response"
+}, u = {
+  /** Host initialization complete */
+  INIT: "forgeframe_init",
+  /** Props update from consumer to host */
+  PROPS: "forgeframe_props",
+  /** Close request from host */
+  CLOSE: "forgeframe_close",
+  /** Resize request from host */
+  RESIZE: "forgeframe_resize",
+  /** Focus request from host */
+  FOCUS: "forgeframe_focus",
+  /** Show request from host */
+  SHOW: "forgeframe_show",
+  /** Hide request from host */
+  HIDE: "forgeframe_hide",
+  /** Error report from host */
+  ERROR: "forgeframe_error",
+  /** Data export from host to consumer */
+  EXPORT: "forgeframe_export",
+  /** Cross-domain function call */
+  CALL: "forgeframe_call",
+  /** Consumer export from host context */
+  CONSUMER_EXPORT: "forgeframe_consumer_export",
+  /** Get sibling components request */
+  GET_SIBLINGS: "forgeframe_get_siblings"
+}, N = "__forgeframe__", pe = "0.0.1";
+class me {
+  /**
+   * Internal storage for event listeners mapped by event name.
+   * @internal
+   */
+  listeners = /* @__PURE__ */ new Map();
+  /**
+   * Subscribes a handler to a specific event.
+   *
+   * @typeParam T - The type of data expected by the event handler
+   * @param event - The name of the event to subscribe to
+   * @param handler - The callback function to invoke when the event is emitted
+   * @returns A function that, when called, unsubscribes the handler from the event
+   *
+   * @example
+   * ```typescript
+   * const unsubscribe = emitter.on<{ userId: string }>('login', (data) => {
+   *   console.log('User logged in:', data.userId);
+   * });
+   * ```
+   *
+   * @public
+   */
+  on(e, s) {
+    return this.listeners.has(e) || this.listeners.set(e, /* @__PURE__ */ new Set()), this.listeners.get(e).add(s), () => this.off(e, s);
+  }
+  /**
+   * Subscribes a handler to an event that will automatically unsubscribe after the first invocation.
+   *
+   * @typeParam T - The type of data expected by the event handler
+   * @param event - The name of the event to subscribe to
+   * @param handler - The callback function to invoke once when the event is emitted
+   * @returns A function that, when called, unsubscribes the handler before it fires
+   *
+   * @remarks
+   * This is useful for one-time event handling, such as waiting for an initialization
+   * event or a single response.
+   *
+   * @example
+   * ```typescript
+   * emitter.once('ready', () => {
+   *   console.log('Component is ready!');
+   * });
+   * ```
+   *
+   * @public
+   */
+  once(e, s) {
+    const n = (i) => (this.off(e, n), s(i));
+    return this.on(e, n);
+  }
+  /**
+   * Emits an event, invoking all registered handlers with the provided data.
+   *
+   * @typeParam T - The type of data to pass to event handlers
+   * @param event - The name of the event to emit
+   * @param data - Optional data to pass to all registered handlers
+   *
+   * @remarks
+   * Handlers are invoked synchronously in the order they were registered.
+   * If a handler throws an error, it is caught and logged to the console,
+   * allowing subsequent handlers to still execute.
+   *
+   * @example
+   * ```typescript
+   * emitter.emit('userAction', { action: 'click', target: 'button' });
+   * ```
+   *
+   * @public
+   */
+  emit(e, s) {
+    const n = this.listeners.get(e);
+    if (n)
+      for (const i of n)
+        try {
+          const r = i(s);
+          r && typeof r == "object" && "catch" in r && typeof r.catch == "function" && r.catch((o) => {
+            console.error(`Error in async event handler for "${e}":`, o);
+          });
+        } catch (r) {
+          console.error(`Error in event handler for "${e}":`, r);
+        }
+  }
+  /**
+   * Unsubscribes a handler from an event, or removes all handlers for the event.
+   *
+   * @param event - The name of the event to unsubscribe from
+   * @param handler - The specific handler to remove. If not provided, all handlers for the event are removed.
+   *
+   * @remarks
+   * When a specific handler is removed and it was the last handler for that event,
+   * the event entry is cleaned up from the internal map.
+   *
+   * @example
+   * ```typescript
+   * // Remove a specific handler
+   * emitter.off('message', myHandler);
+   *
+   * // Remove all handlers for an event
+   * emitter.off('message');
+   * ```
+   *
+   * @public
+   */
+  off(e, s) {
+    if (!s) {
+      this.listeners.delete(e);
+      return;
+    }
+    const n = this.listeners.get(e);
+    n && (n.delete(s), n.size === 0 && this.listeners.delete(e));
+  }
+  /**
+   * Removes all event listeners from the emitter.
+   *
+   * @remarks
+   * This method is typically called during component cleanup or disposal
+   * to ensure no memory leaks from lingering event subscriptions.
+   *
+   * @example
+   * ```typescript
+   * // Clean up all listeners when component is destroyed
+   * emitter.removeAllListeners();
+   * ```
+   *
+   * @public
+   */
+  removeAllListeners() {
+    this.listeners.clear();
+  }
+  /**
+   * Returns the number of listeners registered for a specific event.
+   *
+   * @param event - The name of the event to check
+   * @returns The number of handlers currently subscribed to the event
+   *
+   * @remarks
+   * This method is primarily useful for debugging and testing purposes
+   * to verify that subscriptions are being properly managed.
+   *
+   * @example
+   * ```typescript
+   * console.log(`Active listeners: ${emitter.listenerCount('message')}`);
+   * ```
+   *
+   * @public
+   */
+  listenerCount(e) {
+    return this.listeners.get(e)?.size ?? 0;
+  }
+}
+function Ie() {
+  const t = Date.now().toString(36), e = Math.random().toString(36).slice(2, 11);
+  return `${t}_${e}`;
+}
+function W() {
+  return Math.random().toString(36).slice(2, 11);
+}
+class De {
+  /**
+   * Array of registered cleanup tasks awaiting execution.
+   * @internal
+   */
+  tasks = [];
+  /**
+   * Flag indicating whether cleanup has already been performed.
+   * @internal
+   */
+  cleaned = !1;
+  /**
+   * Registers a cleanup task to be executed when {@link cleanup} is called.
+   *
+   * @param task - The cleanup function to register
+   *
+   * @remarks
+   * If cleanup has already been performed, the task is executed immediately
+   * rather than being registered. This ensures late-registered tasks are
+   * still handled appropriately.
+   *
+   * @example
+   * ```typescript
+   * cleanup.register(() => {
+   *   eventEmitter.removeAllListeners();
+   * });
+   *
+   * cleanup.register(async () => {
+   *   await database.close();
+   * });
+   * ```
+   *
+   * @public
+   */
+  register(e) {
+    if (this.cleaned) {
+      try {
+        e();
+      } catch (s) {
+        console.error("Error in cleanup task:", s);
+      }
+      return;
+    }
+    this.tasks.push(e);
+  }
+  /**
+   * Executes all registered cleanup tasks in LIFO order.
+   *
+   * @returns A Promise that resolves when all cleanup tasks have completed
+   *
+   * @remarks
+   * Tasks are executed in reverse order of registration (LIFO pattern).
+   * Each task is awaited individually, and errors are caught and logged
+   * to prevent one failing task from blocking subsequent cleanup operations.
+   * Calling this method multiple times has no effect after the first call.
+   *
+   * @example
+   * ```typescript
+   * // In a component's destroy lifecycle
+   * async destroy() {
+   *   await this.cleanupManager.cleanup();
+   * }
+   * ```
+   *
+   * @public
+   */
+  async cleanup() {
+    if (this.cleaned) return;
+    this.cleaned = !0;
+    const e = this.tasks.reverse();
+    this.tasks = [];
+    for (const s of e)
+      try {
+        await s();
+      } catch (n) {
+        console.error("Error in cleanup task:", n);
+      }
+  }
+  /**
+   * Checks whether cleanup has already been performed.
+   *
+   * @returns `true` if {@link cleanup} has been called, `false` otherwise
+   *
+   * @example
+   * ```typescript
+   * if (!cleanupManager.isCleaned()) {
+   *   // Safe to register more tasks
+   *   cleanupManager.register(myTask);
+   * }
+   * ```
+   *
+   * @public
+   */
+  isCleaned() {
+    return this.cleaned;
+  }
+  /**
+   * Resets the manager to its initial state, allowing it to be reused.
+   *
+   * @remarks
+   * This method clears all registered tasks and resets the cleaned flag.
+   * It is primarily intended for testing scenarios or cases where the
+   * manager needs to be reused after cleanup.
+   *
+   * @example
+   * ```typescript
+   * // In a test teardown
+   * afterEach(() => {
+   *   cleanupManager.reset();
+   * });
+   * ```
+   *
+   * @public
+   */
+  reset() {
+    this.tasks = [], this.cleaned = !1;
+  }
+}
+function ge() {
+  let t, e;
+  return { promise: new Promise((n, i) => {
+    t = n, e = i;
+  }), resolve: t, reject: e };
+}
+function Ne(t, e, s = "Operation timed out") {
+  return new Promise((n, i) => {
+    const r = setTimeout(() => {
+      i(new Error(`${s} (${e}ms)`));
+    }, e);
+    t.then((o) => {
+      clearTimeout(r), n(o);
+    }).catch((o) => {
+      clearTimeout(r), i(o);
+    });
+  });
+}
+const z = "forgeframe:";
+function A(t) {
+  return z + JSON.stringify(t);
+}
+function Te(t) {
+  if (typeof t != "string" || !t.startsWith(z)) return null;
+  try {
+    const e = t.slice(z.length), s = JSON.parse(e);
+    return !s.id || !s.type || !s.name || !s.source ? null : s;
+  } catch {
+    return null;
+  }
+}
+function re(t, e, s, n) {
+  return {
+    id: t,
+    type: D.REQUEST,
+    name: e,
+    data: s,
+    source: n
+  };
+}
+function ke(t, e, s, n) {
+  return {
+    id: t,
+    type: D.RESPONSE,
+    name: "response",
+    data: e,
+    source: s,
+    error: n ? {
+      message: n.message,
+      stack: n.stack
+    } : void 0
+  };
+}
+class ye {
+  /**
+   * Creates a new Messenger instance.
+   *
+   * @param uid - Unique identifier for this messenger
+   * @param win - The window to listen for messages on
+   * @param domain - The origin domain of this messenger
+   * @param trustedDomains - Optional domains to trust for incoming messages
+   */
+  constructor(e, s = window, n = window.location.origin, i) {
+    this.uid = e, this.win = s, this.domain = n, this.allowedOrigins.add(n), i && this.addTrustedDomain(i), this.setupListener();
+  }
+  /** @internal */
+  pending = /* @__PURE__ */ new Map();
+  /** @internal */
+  handlers = /* @__PURE__ */ new Map();
+  /** @internal */
+  listener = null;
+  /** @internal */
+  destroyed = !1;
+  /** @internal */
+  allowedOrigins = /* @__PURE__ */ new Set();
+  /** @internal */
+  allowedOriginPatterns = [];
+  /**
+   * Adds a trusted domain that can send messages to this messenger.
+   *
+   * @param domain - Domain pattern to trust (string, RegExp, or array)
+   */
+  addTrustedDomain(e) {
+    if (Array.isArray(e))
+      for (const s of e)
+        this.allowedOrigins.add(s);
+    else e instanceof RegExp ? this.allowedOriginPatterns.push(e) : this.allowedOrigins.add(e);
+  }
+  /**
+   * Checks if an origin is trusted.
+   *
+   * @param origin - The origin to check
+   * @returns True if the origin is trusted
+   * @internal
+   */
+  isOriginTrusted(e) {
+    if (this.allowedOrigins.has(e))
+      return !0;
+    for (const s of this.allowedOriginPatterns)
+      if (s.test(e))
+        return !0;
+    return !1;
+  }
+  /**
+   * Sends a message and waits for a response.
+   *
+   * @typeParam T - The data type being sent
+   * @typeParam R - The expected response type
+   * @param targetWin - The target window to send to
+   * @param targetDomain - The target origin domain
+   * @param name - The message name/type
+   * @param data - Optional data payload
+   * @param timeout - Timeout in milliseconds (default: 10000)
+   * @returns Promise resolving to the response data
+   * @throws Error if messenger is destroyed or timeout occurs
+   */
+  async send(e, s, n, i, r = 1e4) {
+    if (this.destroyed)
+      throw new Error("Messenger has been destroyed");
+    const o = W(), a = re(o, n, i, {
+      uid: this.uid,
+      domain: this.domain
+    }), c = ge(), l = setTimeout(() => {
+      this.pending.delete(o), c.reject(new Error(`Message "${n}" timed out after ${r}ms`));
+    }, r);
+    this.pending.set(o, {
+      deferred: c,
+      timeout: l
+    });
+    try {
+      e.postMessage(A(a), s);
+    } catch (h) {
+      throw this.pending.delete(o), clearTimeout(l), h;
+    }
+    return c.promise;
+  }
+  /**
+   * Sends a one-way message without waiting for a response.
+   *
+   * @typeParam T - The data type being sent
+   * @param targetWin - The target window to send to
+   * @param targetDomain - The target origin domain
+   * @param name - The message name/type
+   * @param data - Optional data payload
+   * @throws Error if messenger is destroyed
+   */
+  post(e, s, n, i) {
+    if (this.destroyed)
+      throw new Error("Messenger has been destroyed");
+    const r = W(), o = re(r, n, i, {
+      uid: this.uid,
+      domain: this.domain
+    });
+    e.postMessage(A(o), s);
+  }
+  /**
+   * Registers a handler for incoming messages of a specific type.
+   *
+   * @typeParam T - The expected data type of incoming messages
+   * @typeParam R - The return type of the handler
+   * @param name - The message name/type to handle
+   * @param handler - The handler function
+   * @returns Function to unregister the handler
+   */
+  on(e, s) {
+    return this.handlers.set(e, s), () => this.handlers.delete(e);
+  }
+  /**
+   * Sets up the postMessage event listener.
+   * @internal
+   */
+  setupListener() {
+    this.listener = (e) => {
+      if (e.source === this.win || !this.isOriginTrusted(e.origin))
+        return;
+      const s = Te(e.data);
+      s && this.handleMessage(s, e.source, e.origin);
+    }, this.win.addEventListener("message", this.listener);
+  }
+  /**
+   * Processes a received message.
+   * @internal
+   */
+  async handleMessage(e, s, n) {
+    if (e.type === D.RESPONSE) {
+      const i = this.pending.get(e.id);
+      if (i)
+        if (this.pending.delete(e.id), clearTimeout(i.timeout), e.error) {
+          const r = new Error(e.error.message);
+          r.stack = e.error.stack, i.deferred.reject(r);
+        } else
+          i.deferred.resolve(e.data);
+      return;
+    }
+    if (e.type === D.REQUEST) {
+      const i = this.handlers.get(e.name);
+      if (!i)
+        return;
+      let r, o;
+      try {
+        r = await i(e.data, e.source);
+      } catch (c) {
+        o = c instanceof Error ? c : new Error(String(c));
+      }
+      const a = ke(
+        e.id,
+        r,
+        { uid: this.uid, domain: this.domain },
+        o
+      );
+      try {
+        s.postMessage(A(a), n);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Cleans up the messenger and releases resources.
+   *
+   * @remarks
+   * Removes the message listener, rejects all pending requests,
+   * and clears all handlers.
+   */
+  destroy() {
+    if (!this.destroyed) {
+      this.destroyed = !0, this.listener && (this.win.removeEventListener("message", this.listener), this.listener = null);
+      for (const e of this.pending.values())
+        clearTimeout(e.timeout), e.deferred.reject(new Error("Messenger destroyed"));
+      this.pending.clear(), this.handlers.clear();
+    }
+  }
+  /**
+   * Checks if the messenger has been destroyed.
+   *
+   * @returns True if destroy() has been called
+   */
+  isDestroyed() {
+    return this.destroyed;
+  }
+}
+const oe = 500;
+class B {
+  /**
+   * Creates a new FunctionBridge instance.
+   *
+   * @param messenger - The messenger to use for cross-domain calls
+   */
+  constructor(e) {
+    this.messenger = e, this.setupCallHandler();
+  }
+  /** @internal */
+  localFunctions = /* @__PURE__ */ new Map();
+  /** @internal */
+  remoteFunctions = /* @__PURE__ */ new Map();
+  /**
+   * Tracks function IDs from the current serialization batch.
+   * Used for cleanup of stale references when props are updated.
+   * @internal
+   */
+  currentBatchIds = /* @__PURE__ */ new Set();
+  /**
+   * Serializes a local function to a transferable reference.
+   *
+   * @param fn - The function to serialize
+   * @param name - Optional name for debugging
+   * @returns A function reference that can be sent across domains
+   */
+  serialize(e, s) {
+    if (this.localFunctions.size >= oe) {
+      const i = this.localFunctions.keys().next().value;
+      i && this.localFunctions.delete(i);
+    }
+    const n = W();
+    return this.localFunctions.set(n, e), this.currentBatchIds.add(n), {
+      __type__: "function",
+      __id__: n,
+      __name__: s || e.name || "anonymous"
+    };
+  }
+  /**
+   * Deserializes a function reference to a callable wrapper.
+   *
+   * @remarks
+   * The returned function, when called, will invoke the original function
+   * in the remote window via postMessage and return the result.
+   *
+   * @param ref - The function reference to deserialize
+   * @param targetWin - The window containing the original function
+   * @param targetDomain - The origin of the target window
+   * @returns A callable wrapper function
+   */
+  deserialize(e, s, n) {
+    const i = `${e.__id__}`, r = this.remoteFunctions.get(i);
+    if (r) return r;
+    if (this.remoteFunctions.size >= oe) {
+      const a = this.remoteFunctions.keys().next().value;
+      a && this.remoteFunctions.delete(a);
+    }
+    const o = async (...a) => this.messenger.send(s, n, u.CALL, {
+      id: e.__id__,
+      args: a
+    });
+    return Object.defineProperty(o, "name", {
+      value: e.__name__,
+      configurable: !0
+    }), this.remoteFunctions.set(i, o), o;
+  }
+  /**
+   * Type guard to check if a value is a function reference.
+   *
+   * @param value - The value to check
+   * @returns True if the value is a FunctionRef
+   */
+  static isFunctionRef(e) {
+    return typeof e == "object" && e !== null && e.__type__ === "function" && typeof e.__id__ == "string";
+  }
+  /**
+   * Sets up the handler for incoming function call messages.
+   * @internal
+   */
+  setupCallHandler() {
+    this.messenger.on(
+      u.CALL,
+      async ({ id: e, args: s }) => {
+        const n = this.localFunctions.get(e);
+        if (!n)
+          throw new Error(`Function with id "${e}" not found`);
+        return n(...s);
+      }
+    );
+  }
+  /**
+   * Removes a local function reference.
+   *
+   * @param id - The function reference ID to remove
+   */
+  removeLocal(e) {
+    this.localFunctions.delete(e);
+  }
+  /**
+   * Starts a new serialization batch.
+   *
+   * @remarks
+   * Call this before serializing a new set of props. After serialization,
+   * call {@link finishBatch} to clean up functions from previous batches.
+   *
+   * @example
+   * ```typescript
+   * bridge.startBatch();
+   * const serialized = serializeFunctions(props, bridge);
+   * bridge.finishBatch();
+   * ```
+   */
+  startBatch() {
+    this.currentBatchIds.clear();
+  }
+  /**
+   * Finishes the current batch and removes functions not in this batch.
+   *
+   * @remarks
+   * This cleans up function references from previous prop updates that
+   * are no longer needed, preventing memory leaks.
+   *
+   * @param keepPrevious - If true, keeps previous batch functions (default: false)
+   */
+  finishBatch(e = !1) {
+    if (e) {
+      this.currentBatchIds.clear();
+      return;
+    }
+    for (const s of this.localFunctions.keys())
+      this.currentBatchIds.has(s) || this.localFunctions.delete(s);
+    this.currentBatchIds.clear();
+  }
+  /**
+   * Clears all remote function references.
+   *
+   * @remarks
+   * Call this when the remote window is no longer accessible
+   * (e.g., closed or navigated away).
+   */
+  clearRemote() {
+    this.remoteFunctions.clear();
+  }
+  /**
+   * Returns the current number of registered local functions.
+   * Useful for debugging and monitoring.
+   */
+  get localFunctionCount() {
+    return this.localFunctions.size;
+  }
+  /**
+   * Returns the current number of cached remote functions.
+   * Useful for debugging and monitoring.
+   */
+  get remoteFunctionCount() {
+    return this.remoteFunctions.size;
+  }
+  /**
+   * Cleans up all function references.
+   */
+  destroy() {
+    this.localFunctions.clear(), this.remoteFunctions.clear(), this.currentBatchIds.clear();
+  }
+}
+function M(t, e, s = /* @__PURE__ */ new WeakSet()) {
+  if (typeof t == "function")
+    return e.serialize(t);
+  if (Array.isArray(t)) {
+    if (s.has(t))
+      throw new Error("Circular reference detected in props - arrays cannot contain circular references");
+    return s.add(t), t.map((n) => M(n, e, s));
+  }
+  if (typeof t == "object" && t !== null) {
+    if (s.has(t))
+      throw new Error("Circular reference detected in props - objects cannot contain circular references");
+    s.add(t);
+    const n = {};
+    for (const [i, r] of Object.entries(t))
+      n[i] = M(r, e, s);
+    return n;
+  }
+  return t;
+}
+function U(t, e, s, n, i = /* @__PURE__ */ new WeakSet()) {
+  if (B.isFunctionRef(t))
+    return e.deserialize(t, s, n);
+  if (Array.isArray(t)) {
+    if (i.has(t))
+      throw new Error("Circular reference detected in serialized props");
+    return i.add(t), t.map(
+      (r) => U(r, e, s, n, i)
+    );
+  }
+  if (typeof t == "object" && t !== null) {
+    if (i.has(t))
+      throw new Error("Circular reference detected in serialized props");
+    i.add(t);
+    const r = {};
+    for (const [o, a] of Object.entries(t))
+      r[o] = U(a, e, s, n, i);
+    return r;
+  }
+  return t;
+}
+function j(t = window) {
+  try {
+    return t.location.origin;
+  } catch {
+    return "";
+  }
+}
+function _e(t, e = window) {
+  try {
+    return t.location.origin === e.location.origin;
+  } catch {
+    return !1;
+  }
+}
+function we(t, e) {
+  return typeof t == "string" ? t === "*" ? !0 : t === e : t instanceof RegExp ? t.test(e) : Array.isArray(t) ? t.some((s) => we(s, e)) : !1;
+}
+function Ee(t) {
+  if (!t) return !0;
+  try {
+    return t.closed;
+  } catch {
+    return !0;
+  }
+}
+function $e(t = window) {
+  try {
+    return t.opener;
+  } catch {
+    return null;
+  }
+}
+function Fe(t = window) {
+  try {
+    const e = t.parent;
+    return e && e !== t ? e : null;
+  } catch {
+    return null;
+  }
+}
+function Le(t = window) {
+  try {
+    return t.parent !== t;
+  } catch {
+    return !0;
+  }
+}
+function Ae(t = window) {
+  try {
+    return t.opener !== null && t.opener !== void 0;
+  } catch {
+    return !1;
+  }
+}
+const ae = 32 * 1024;
+function He(t) {
+  const e = We(t);
+  return `${N}${e}`;
+}
+function be(t) {
+  if (!t || !t.startsWith(N))
+    return null;
+  const e = t.slice(N.length);
+  return ze(e);
+}
+function J(t = window) {
+  try {
+    return t.name.startsWith(N);
+  } catch {
+    return !1;
+  }
+}
+function H(t, e = window) {
+  return be(e.name)?.tag === t;
+}
+function We(t) {
+  try {
+    const e = JSON.stringify(t), s = btoa(encodeURIComponent(e)), n = new Blob([s]).size;
+    if (n > ae)
+      throw new Error(
+        `Payload size (${Math.round(n / 1024)}KB) exceeds maximum allowed size (${ae / 1024}KB). Consider reducing the amount of data passed via props.`
+      );
+    return s;
+  } catch (e) {
+    throw e instanceof Error && e.message.includes("Payload size") ? e : new Error(`Failed to encode payload: ${e}`);
+  }
+}
+function ze(t) {
+  try {
+    const e = decodeURIComponent(atob(t));
+    return JSON.parse(e);
+  } catch {
+    return null;
+  }
+}
+function Me(t) {
+  return {
+    uid: t.uid,
+    tag: t.tag,
+    version: pe,
+    context: t.context,
+    consumerDomain: t.consumerDomain,
+    props: t.props,
+    exports: t.exports,
+    children: t.children
+  };
+}
+function Ue(t = window) {
+  return be(t.name);
+}
+const ce = 100, w = /* @__PURE__ */ new Map();
+function je() {
+  const t = [];
+  for (const [e, s] of w.entries())
+    Ee(s) && t.push(e);
+  for (const e of t)
+    w.delete(e);
+}
+function Be(t, e) {
+  if (w.size >= ce && je(), w.size >= ce) {
+    const s = w.keys().next().value;
+    s && w.delete(s);
+  }
+  w.set(t, e);
+}
+function Je(t) {
+  w.delete(t);
+}
+class m {
+  /** @internal */
+  _optional = !1;
+  /** @internal */
+  _nullable = !1;
+  /** @internal */
+  _default;
+  /**
+   * StandardSchemaV1 implementation.
+   * @internal
+   */
+  "~standard" = {
+    version: 1,
+    vendor: "forgeframe",
+    validate: (e) => e === null ? this._nullable ? { value: null } : { issues: [{ message: "Expected a value, got null" }] } : e === void 0 ? this._default !== void 0 ? { value: typeof this._default == "function" ? this._default() : this._default } : this._optional ? { value: void 0 } : { issues: [{ message: "Required" }] } : this._validate(e)
+  };
+  /**
+   * Marks this prop as optional.
+   *
+   * @returns Schema that accepts undefined
+   *
+   * @example
+   * ```typescript
+   * props: {
+   *   nickname: prop.string().optional(),
+   * }
+   * ```
+   */
+  optional() {
+    const e = this._clone();
+    return e._optional = !0, e;
+  }
+  /**
+   * Marks this prop as nullable (accepts null).
+   *
+   * @returns Schema that accepts null
+   *
+   * @example
+   * ```typescript
+   * props: {
+   *   middleName: prop.string().nullable(),
+   * }
+   * ```
+   */
+  nullable() {
+    const e = this._clone();
+    return e._nullable = !0, e;
+  }
+  /**
+   * Sets a default value for this prop.
+   *
+   * @param value - Default value or function returning default
+   * @returns Schema with default value
+   *
+   * @example
+   * ```typescript
+   * props: {
+   *   count: prop.number().default(0),
+   *   id: prop.string().default(() => crypto.randomUUID()),
+   * }
+   * ```
+   */
+  default(e) {
+    const s = this._clone();
+    return s._default = e, s;
+  }
+}
+class V extends m {
+  /** @internal */
+  _minLength;
+  /** @internal */
+  _maxLength;
+  /** @internal */
+  _pattern;
+  /** @internal */
+  _patternMessage;
+  /** @internal */
+  _trim = !1;
+  /** @internal */
+  _validate(e) {
+    if (typeof e != "string")
+      return {
+        issues: [{ message: `Expected string, got ${typeof e}` }]
+      };
+    const s = this._trim ? e.trim() : e;
+    return this._minLength !== void 0 && s.length < this._minLength ? {
+      issues: [
+        { message: `String must be at least ${this._minLength} characters` }
+      ]
+    } : this._maxLength !== void 0 && s.length > this._maxLength ? {
+      issues: [
+        { message: `String must be at most ${this._maxLength} characters` }
+      ]
+    } : this._pattern && !this._pattern.test(s) ? {
+      issues: [
+        {
+          message: this._patternMessage || `String must match pattern ${this._pattern}`
+        }
+      ]
+    } : { value: s };
+  }
+  /** @internal */
+  _clone() {
+    const e = new V();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e._minLength = this._minLength, e._maxLength = this._maxLength, e._pattern = this._pattern, e._patternMessage = this._patternMessage, e._trim = this._trim, e;
+  }
+  /**
+   * Requires minimum string length.
+   *
+   * @param length - Minimum number of characters
+   *
+   * @example
+   * ```typescript
+   * name: prop.string().min(2)
+   * ```
+   */
+  min(e) {
+    const s = this._clone();
+    return s._minLength = e, s;
+  }
+  /**
+   * Requires maximum string length.
+   *
+   * @param length - Maximum number of characters
+   *
+   * @example
+   * ```typescript
+   * bio: prop.string().max(500)
+   * ```
+   */
+  max(e) {
+    const s = this._clone();
+    return s._maxLength = e, s;
+  }
+  /**
+   * Requires exact string length.
+   *
+   * @param length - Exact number of characters required
+   *
+   * @example
+   * ```typescript
+   * code: prop.string().length(6)
+   * ```
+   */
+  length(e) {
+    const s = this._clone();
+    return s._minLength = e, s._maxLength = e, s;
+  }
+  /**
+   * Requires string to match a regex pattern.
+   *
+   * @param regex - Pattern to match
+   * @param message - Optional custom error message
+   *
+   * @example
+   * ```typescript
+   * slug: prop.string().pattern(/^[a-z0-9-]+$/, 'Invalid slug format')
+   * ```
+   */
+  pattern(e, s) {
+    const n = this._clone();
+    return n._pattern = e, n._patternMessage = s, n;
+  }
+  /**
+   * Validates as email address.
+   *
+   * @example
+   * ```typescript
+   * email: prop.string().email()
+   * ```
+   */
+  email() {
+    return this.pattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, "Invalid email address");
+  }
+  /**
+   * Validates as URL.
+   *
+   * @example
+   * ```typescript
+   * website: prop.string().url()
+   * ```
+   */
+  url() {
+    return this.pattern(/^https?:\/\/.+/, "Invalid URL");
+  }
+  /**
+   * Validates as UUID.
+   *
+   * @example
+   * ```typescript
+   * id: prop.string().uuid()
+   * ```
+   */
+  uuid() {
+    return this.pattern(
+      /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i,
+      "Invalid UUID"
+    );
+  }
+  /**
+   * Trims whitespace from both ends of the string.
+   *
+   * @remarks
+   * The trimmed value is used for validation and returned as the result.
+   *
+   * @example
+   * ```typescript
+   * name: prop.string().trim()
+   * username: prop.string().trim().min(3)
+   * ```
+   */
+  trim() {
+    const e = this._clone();
+    return e._trim = !0, e;
+  }
+  /**
+   * Requires non-empty string (at least 1 character).
+   *
+   * @example
+   * ```typescript
+   * title: prop.string().nonempty()
+   * ```
+   */
+  nonempty() {
+    const e = this._clone();
+    return e._minLength = 1, e;
+  }
+}
+class q extends m {
+  /** @internal */
+  _min;
+  /** @internal */
+  _max;
+  /** @internal */
+  _int = !1;
+  /** @internal */
+  _validate(e) {
+    return typeof e != "number" || Number.isNaN(e) ? {
+      issues: [{ message: `Expected number, got ${typeof e}` }]
+    } : this._int && !Number.isInteger(e) ? { issues: [{ message: "Expected integer" }] } : this._min !== void 0 && e < this._min ? { issues: [{ message: `Number must be >= ${this._min}` }] } : this._max !== void 0 && e > this._max ? { issues: [{ message: `Number must be <= ${this._max}` }] } : { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new q();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e._min = this._min, e._max = this._max, e._int = this._int, e;
+  }
+  /**
+   * Requires minimum value.
+   *
+   * @param n - Minimum value (inclusive)
+   *
+   * @example
+   * ```typescript
+   * age: prop.number().min(0)
+   * ```
+   */
+  min(e) {
+    const s = this._clone();
+    return s._min = e, s;
+  }
+  /**
+   * Requires maximum value.
+   *
+   * @param n - Maximum value (inclusive)
+   *
+   * @example
+   * ```typescript
+   * rating: prop.number().max(5)
+   * ```
+   */
+  max(e) {
+    const s = this._clone();
+    return s._max = e, s;
+  }
+  /**
+   * Requires integer value.
+   *
+   * @example
+   * ```typescript
+   * count: prop.number().int()
+   * ```
+   */
+  int() {
+    const e = this._clone();
+    return e._int = !0, e;
+  }
+  /**
+   * Requires positive number (> 0).
+   *
+   * @example
+   * ```typescript
+   * price: prop.number().positive()
+   * ```
+   */
+  positive() {
+    const e = this._clone();
+    return e._min = Number.MIN_VALUE, e;
+  }
+  /**
+   * Requires non-negative number (>= 0).
+   *
+   * @example
+   * ```typescript
+   * quantity: prop.number().nonnegative()
+   * ```
+   */
+  nonnegative() {
+    const e = this._clone();
+    return e._min = 0, e;
+  }
+  /**
+   * Requires negative number (< 0).
+   *
+   * @example
+   * ```typescript
+   * debt: prop.number().negative()
+   * ```
+   */
+  negative() {
+    const e = this._clone();
+    return e._max = -Number.MIN_VALUE, e;
+  }
+}
+class X extends m {
+  /** @internal */
+  _validate(e) {
+    return typeof e != "boolean" ? {
+      issues: [{ message: `Expected boolean, got ${typeof e}` }]
+    } : { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new X();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e;
+  }
+}
+class Y extends m {
+  /** @internal */
+  _validate(e) {
+    return typeof e != "function" ? {
+      issues: [{ message: `Expected function, got ${typeof e}` }]
+    } : { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new Y();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e;
+  }
+}
+class T extends m {
+  /** @internal */
+  _itemSchema;
+  /** @internal */
+  _minLength;
+  /** @internal */
+  _maxLength;
+  /** @internal */
+  _validate(e) {
+    if (!Array.isArray(e))
+      return {
+        issues: [{ message: `Expected array, got ${typeof e}` }]
+      };
+    if (this._minLength !== void 0 && e.length < this._minLength)
+      return {
+        issues: [
+          { message: `Array must have at least ${this._minLength} items` }
+        ]
+      };
+    if (this._maxLength !== void 0 && e.length > this._maxLength)
+      return {
+        issues: [
+          { message: `Array must have at most ${this._maxLength} items` }
+        ]
+      };
+    if (this._itemSchema) {
+      const s = [];
+      for (let n = 0; n < e.length; n++) {
+        const i = this._itemSchema["~standard"].validate(e[n]);
+        if (i instanceof Promise)
+          throw new Error(
+            "Async schema validation is not supported. Use synchronous schemas."
+          );
+        if (i.issues)
+          return {
+            issues: i.issues.map((r) => ({
+              ...r,
+              path: [n, ...r.path || []]
+            }))
+          };
+        s.push(i.value);
+      }
+      return { value: s };
+    }
+    return { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new T();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e._itemSchema = this._itemSchema, e._minLength = this._minLength, e._maxLength = this._maxLength, e;
+  }
+  /**
+   * Specifies the schema for array items.
+   *
+   * @typeParam U - Item type
+   * @param schema - Schema for validating each item
+   *
+   * @example
+   * ```typescript
+   * tags: prop.array().of(prop.string())
+   * scores: prop.array().of(prop.number().min(0).max(100))
+   * ```
+   */
+  of(e) {
+    const s = new T();
+    return s._optional = this._optional, s._nullable = this._nullable, s._itemSchema = e, s._minLength = this._minLength, s._maxLength = this._maxLength, s;
+  }
+  /**
+   * Requires minimum array length.
+   *
+   * @param length - Minimum number of items
+   *
+   * @example
+   * ```typescript
+   * items: prop.array().min(1)
+   * ```
+   */
+  min(e) {
+    const s = this._clone();
+    return s._minLength = e, s;
+  }
+  /**
+   * Requires maximum array length.
+   *
+   * @param length - Maximum number of items
+   *
+   * @example
+   * ```typescript
+   * selections: prop.array().max(5)
+   * ```
+   */
+  max(e) {
+    const s = this._clone();
+    return s._maxLength = e, s;
+  }
+  /**
+   * Requires non-empty array.
+   *
+   * @example
+   * ```typescript
+   * options: prop.array().nonempty()
+   * ```
+   */
+  nonempty() {
+    return this.min(1);
+  }
+}
+class k extends m {
+  /** @internal */
+  _shape;
+  /** @internal */
+  _strict = !1;
+  /** @internal */
+  _validate(e) {
+    if (typeof e != "object" || e === null || Array.isArray(e))
+      return {
+        issues: [
+          {
+            message: `Expected object, got ${Array.isArray(e) ? "array" : typeof e}`
+          }
+        ]
+      };
+    const s = e, n = {};
+    if (this._shape) {
+      if (this._strict) {
+        const i = new Set(Object.keys(this._shape));
+        for (const r of Object.keys(s))
+          if (!i.has(r))
+            return {
+              issues: [{ message: `Unknown key: ${r}`, path: [r] }]
+            };
+      }
+      for (const [i, r] of Object.entries(this._shape)) {
+        const o = r["~standard"].validate(s[i]);
+        if (o instanceof Promise)
+          throw new Error(
+            "Async schema validation is not supported. Use synchronous schemas."
+          );
+        if (o.issues)
+          return {
+            issues: o.issues.map((a) => ({
+              ...a,
+              path: [i, ...a.path || []]
+            }))
+          };
+        n[i] = o.value;
+      }
+      if (!this._strict)
+        for (const i of Object.keys(s))
+          i in this._shape || (n[i] = s[i]);
+      return { value: n };
+    }
+    return { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new k();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e._shape = this._shape, e._strict = this._strict, e;
+  }
+  /**
+   * Defines the shape of the object with field schemas.
+   *
+   * @typeParam S - Shape definition type
+   * @param shape - Object mapping field names to schemas
+   *
+   * @example
+   * ```typescript
+   * user: prop.object().shape({
+   *   name: prop.string(),
+   *   age: prop.number().optional(),
+   * })
+   * ```
+   */
+  shape(e) {
+    const s = new k();
+    return s._optional = this._optional, s._nullable = this._nullable, s._shape = e, s._strict = this._strict, s;
+  }
+  /**
+   * Rejects objects with unknown keys.
+   *
+   * @example
+   * ```typescript
+   * config: prop.object().shape({ debug: prop.boolean() }).strict()
+   * ```
+   */
+  strict() {
+    const e = this._clone();
+    return e._strict = !0, e;
+  }
+}
+class Z extends m {
+  /** @internal */
+  _value;
+  constructor(e) {
+    super(), this._value = e;
+  }
+  /** @internal */
+  _validate(e) {
+    return e !== this._value ? {
+      issues: [{ message: `Expected ${JSON.stringify(this._value)}, got ${JSON.stringify(e)}` }]
+    } : { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new Z(this._value);
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e;
+  }
+}
+class G extends m {
+  /** @internal */
+  _values;
+  constructor(e) {
+    super(), this._values = e;
+  }
+  /** @internal */
+  _validate(e) {
+    return this._values.includes(e) ? { value: e } : {
+      issues: [
+        {
+          message: `Expected one of [${this._values.map((s) => JSON.stringify(s)).join(", ")}], got ${JSON.stringify(e)}`
+        }
+      ]
+    };
+  }
+  /** @internal */
+  _clone() {
+    const e = new G(this._values);
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e;
+  }
+}
+class K extends m {
+  constructor() {
+    super(), this._nullable = !0;
+  }
+  /** @internal */
+  _validate(e) {
+    return { value: e };
+  }
+  /** @internal */
+  _clone() {
+    const e = new K();
+    return e._optional = this._optional, e._nullable = this._nullable, e._default = this._default, e;
+  }
+}
+const d = {
+  /**
+   * Creates a string schema.
+   *
+   * @example
+   * ```typescript
+   * prop.string()
+   * prop.string().min(1).max(100)
+   * prop.string().email()
+   * prop.string().url()
+   * prop.string().pattern(/^[a-z]+$/)
+   * ```
+   */
+  string: () => new V(),
+  /**
+   * Creates a number schema.
+   *
+   * @example
+   * ```typescript
+   * prop.number()
+   * prop.number().min(0).max(100)
+   * prop.number().int()
+   * prop.number().positive()
+   * ```
+   */
+  number: () => new q(),
+  /**
+   * Creates a boolean schema.
+   *
+   * @example
+   * ```typescript
+   * prop.boolean()
+   * prop.boolean().default(false)
+   * ```
+   */
+  boolean: () => new X(),
+  /**
+   * Creates a function schema.
+   *
+   * @typeParam T - Function type signature
+   *
+   * @example
+   * ```typescript
+   * prop.function()
+   * prop.function<() => void>()
+   * prop.function<(data: { id: string }) => Promise<void>>()
+   * ```
+   */
+  function: () => new Y(),
+  /**
+   * Creates an array schema.
+   *
+   * @typeParam T - Array item type
+   *
+   * @example
+   * ```typescript
+   * prop.array()
+   * prop.array().of(prop.string())
+   * prop.array().of(prop.number()).min(1).max(10)
+   * ```
+   */
+  array: () => new T(),
+  /**
+   * Creates an object schema.
+   *
+   * @typeParam T - Object type
+   *
+   * @example
+   * ```typescript
+   * prop.object()
+   * prop.object().shape({
+   *   name: prop.string(),
+   *   age: prop.number().optional(),
+   * })
+   * prop.object().shape({ key: prop.string() }).strict()
+   * ```
+   */
+  object: () => new k(),
+  /**
+   * Creates a literal schema for exact value matching.
+   *
+   * @param value - The exact value to match
+   *
+   * @example
+   * ```typescript
+   * prop.literal('active')
+   * prop.literal(42)
+   * prop.literal(true)
+   * ```
+   */
+  literal: (t) => new Z(t),
+  /**
+   * Creates an enum schema for a set of allowed values.
+   *
+   * @param values - Array of allowed values
+   *
+   * @example
+   * ```typescript
+   * prop.enum(['pending', 'active', 'completed'])
+   * prop.enum([1, 2, 3])
+   * ```
+   */
+  enum: (t) => new G(t),
+  /**
+   * Creates a schema that accepts any value.
+   *
+   * @remarks
+   * Use sparingly - prefer typed schemas when possible.
+   *
+   * @example
+   * ```typescript
+   * prop.any()
+   * ```
+   */
+  any: () => new K()
+}, R = {
+  uid: {
+    schema: d.string().optional(),
+    sendToHost: !0
+  },
+  tag: {
+    schema: d.string().optional(),
+    sendToHost: !0
+  },
+  dimensions: {
+    schema: d.object().default(() => ({ width: "100%", height: "100%" })),
+    sendToHost: !1
+  },
+  timeout: {
+    schema: d.number().default(1e4),
+    sendToHost: !1
+  },
+  cspNonce: {
+    schema: d.string().optional(),
+    sendToHost: !0
+  },
+  // Lifecycle callbacks - not sent to host (consumer-only)
+  onDisplay: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onRendered: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onRender: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onPrerendered: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onPrerender: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onClose: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onDestroy: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onResize: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onFocus: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onError: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  },
+  onProps: {
+    schema: d.function().optional(),
+    sendToHost: !1
+  }
+};
+function E(t) {
+  return typeof t == "object" && t !== null && "~standard" in t && typeof t["~standard"] == "object" && t["~standard"] !== null && t["~standard"].version === 1 && typeof t["~standard"].validate == "function";
+}
+function Ve(t, e, s) {
+  const n = t["~standard"].validate(e);
+  if (n instanceof Promise)
+    throw new Error(
+      `Prop "${s}" uses an async schema. ForgeFrame only supports synchronous schema validation. Please use a synchronous schema or remove async operations (like database lookups) from your schema definition.`
+    );
+  if (n.issues) {
+    const i = n.issues.map((r) => `${qe(r.path, s)}: ${r.message}`);
+    throw new Error(`Validation failed: ${i.join("; ")}`);
+  }
+  return n.value;
+}
+function qe(t, e) {
+  if (!t || t.length === 0)
+    return e;
+  const s = t.map((n) => typeof n == "object" && n !== null && "key" in n ? String(n.key) : String(n));
+  return `${e}.${s.join(".")}`;
+}
+function le(t, e, s) {
+  const n = {
+    ...R,
+    ...e
+  }, i = {};
+  for (const [r, o] of Object.entries(n)) {
+    const c = E(o) ? { schema: o } : o;
+    let l;
+    const h = c.alias, g = r in t, y = h && h in t;
+    if (g)
+      l = t[r];
+    else if (y)
+      l = t[h];
+    else if (c.value)
+      l = c.value(s);
+    else if (c.default !== void 0)
+      l = typeof c.default == "function" ? c.default(s) : c.default;
+    else if (c.schema && E(c.schema)) {
+      const b = c.schema["~standard"].validate(void 0);
+      !(b instanceof Promise) && !b.issues && (l = b.value);
+    }
+    l !== void 0 && c.decorate && (l = c.decorate({ value: l, props: i })), i[r] = l;
+  }
+  return i;
+}
+function Xe(t, e) {
+  const s = {
+    ...R,
+    ...e
+  };
+  for (const [n, i] of Object.entries(s)) {
+    const r = E(i), o = r ? { schema: i } : i;
+    let a = t[n];
+    if (o.required && a === void 0)
+      throw new Error(`Prop "${n}" is required but was not provided`);
+    if (o.schema && E(o.schema))
+      (a !== void 0 || r) && (a = Ve(o.schema, a, n), t[n] = a);
+    else if (a === void 0)
+      continue;
+    o.validate && o.validate({ value: a, props: t });
+  }
+}
+function ue(t, e, s, n) {
+  const i = {
+    ...R,
+    ...e
+  }, r = {};
+  for (const [o, a] of Object.entries(i)) {
+    const l = E(a) ? { schema: a } : a, h = t[o];
+    if (l.sendToHost === !1 || l.sameDomain && !n) continue;
+    if (l.trustedDomains) {
+      const y = l.trustedDomains;
+      if (!we(y, s)) continue;
+    }
+    let g = h;
+    l.hostDecorate && h !== void 0 && (g = l.hostDecorate({ value: h, props: t })), r[o] = g;
+  }
+  return r;
+}
+function Ye(t, e) {
+  const s = new URLSearchParams(), n = {
+    ...R,
+    ...e
+  };
+  for (const [i, r] of Object.entries(n)) {
+    const a = E(r) ? { schema: r } : r, c = t[i];
+    if (c === void 0 || typeof c == "function" || !a.queryParam) continue;
+    const l = typeof a.queryParam == "string" ? a.queryParam : i;
+    let h;
+    typeof a.queryParam == "function" ? h = a.queryParam({ value: c }) : typeof c == "object" ? h = JSON.stringify(c) : h = String(c), s.set(l, h);
+  }
+  return s;
+}
+function Pe(t, e = "") {
+  const s = [];
+  for (const [n, i] of Object.entries(t)) {
+    const r = e ? `${e}.${n}` : n;
+    if (i !== null && typeof i == "object" && !Array.isArray(i))
+      s.push(Pe(i, r));
+    else {
+      const o = encodeURIComponent(JSON.stringify(i));
+      s.push(`${r}=${o}`);
+    }
+  }
+  return s.filter(Boolean).join("&");
+}
+function Ze(t) {
+  const e = {};
+  if (!t) return e;
+  const s = t.split("&");
+  for (const n of s) {
+    const [i, r] = n.split("=");
+    if (!i || r === void 0) continue;
+    let o;
+    try {
+      o = JSON.parse(decodeURIComponent(r));
+    } catch {
+      o = decodeURIComponent(r);
+    }
+    const a = i.split(".");
+    let c = e;
+    for (let l = 0; l < a.length - 1; l++) {
+      const h = a[l];
+      (!(h in c) || typeof c[h] != "object") && (c[h] = {}), c = c[h];
+    }
+    c[a[a.length - 1]] = o;
+  }
+  return e;
+}
+function Ge(t) {
+  return typeof t == "object" && t !== null && t.__type__ === "dotify" && typeof t.__value__ == "string";
+}
+function he(t, e, s) {
+  const n = {
+    ...R,
+    ...e
+  }, i = {};
+  for (const [r, o] of Object.entries(t)) {
+    if (o === void 0) continue;
+    const a = n[r];
+    i[r] = Ke(o, a, s);
+  }
+  return i;
+}
+function Ke(t, e, s) {
+  if (typeof t == "function")
+    return s.serialize(t);
+  const n = e?.serialization ?? I.JSON;
+  if (n === I.BASE64 && typeof t == "object") {
+    const i = JSON.stringify(t);
+    return {
+      __type__: "base64",
+      __value__: btoa(encodeURIComponent(i))
+    };
+  }
+  return n === I.DOTIFY && typeof t == "object" && t !== null && !Array.isArray(t) ? {
+    __type__: "dotify",
+    __value__: Pe(t)
+  } : M(t, s);
+}
+function de(t, e, s, n, i, r) {
+  const o = {
+    ...R,
+    ...e
+  }, a = {};
+  for (const [c, l] of Object.entries(t)) {
+    const h = o[c];
+    a[c] = Qe(
+      l,
+      h,
+      s,
+      n,
+      i,
+      r
+    );
+  }
+  return a;
+}
+function Qe(t, e, s, n, i, r) {
+  if (et(t))
+    try {
+      const o = decodeURIComponent(atob(t.__value__));
+      return JSON.parse(o);
+    } catch {
+      return t;
+    }
+  if (Ge(t))
+    try {
+      return Ze(t.__value__);
+    } catch {
+      return t;
+    }
+  return U(t, n, i, r);
+}
+function et(t) {
+  return typeof t == "object" && t !== null && t.__type__ === "base64" && typeof t.__value__ == "string";
+}
+function P(t, e = "100%") {
+  return t === void 0 ? e : typeof t == "number" ? `${t}px` : t;
+}
+function $(t, e) {
+  if (t === void 0) return e;
+  if (typeof t == "number") return t;
+  const s = parseInt(t, 10);
+  return isNaN(s) ? e : s;
+}
+function tt(t) {
+  try {
+    t.src = "about:blank", t.parentNode?.removeChild(t);
+  } catch {
+  }
+}
+function st(t, e) {
+  rt(t, e);
+}
+function nt(t) {
+  t.style.display = "", t.style.visibility = "visible";
+}
+function fe(t) {
+  t.style.display = "none", t.style.visibility = "hidden";
+}
+function it(t) {
+  try {
+    t.focus(), t.contentWindow?.focus();
+  } catch {
+  }
+}
+function rt(t, e) {
+  e.width !== void 0 && (t.style.width = P(e.width)), e.height !== void 0 && (t.style.height = P(e.height));
+}
+class Re extends Error {
+  constructor(e = "Popup blocked by browser") {
+    super(e), this.name = "PopupOpenError";
+  }
+}
+function ot(t) {
+  const { url: e, name: s, dimensions: n } = t, i = $(n.width, 500), r = $(n.height, 500), o = Math.floor(window.screenX + (window.outerWidth - i) / 2), a = Math.floor(window.screenY + (window.outerHeight - r) / 2), c = [
+    `width=${i}`,
+    `height=${r}`,
+    `left=${o}`,
+    `top=${a}`,
+    "menubar=no",
+    "toolbar=no",
+    "location=yes",
+    // Required for security
+    "status=no",
+    "resizable=yes",
+    "scrollbars=yes"
+  ].join(","), l = window.open(e, s, c);
+  if (!l || lt(l))
+    throw new Re();
+  return l;
+}
+function at(t) {
+  try {
+    t.closed || t.close();
+  } catch {
+  }
+}
+function ct(t) {
+  try {
+    t.closed || t.focus();
+  } catch {
+  }
+}
+function lt(t) {
+  if (!t) return !0;
+  try {
+    return !!(t.closed || t.innerHeight === 0 || t.innerWidth === 0);
+  } catch {
+    return !0;
+  }
+}
+function ut(t, e, s = {}) {
+  const {
+    initialInterval: n = 100,
+    // Start fast to catch quick closes
+    maxInterval: i = 2e3,
+    // Cap at 2 seconds
+    multiplier: r = 1.5
+    // Exponential backoff multiplier
+  } = s;
+  let o = n, a, c = !1;
+  const l = () => {
+    try {
+      e();
+    } catch (g) {
+      console.error("Error in popup close callback:", g);
+    }
+  }, h = () => {
+    if (!c) {
+      try {
+        if (t.closed) {
+          l();
+          return;
+        }
+      } catch {
+        l();
+        return;
+      }
+      o = Math.min(o * r, i), a = setTimeout(h, o);
+    }
+  };
+  return a = setTimeout(h, o), () => {
+    c = !0, clearTimeout(a);
+  };
+}
+function ht(t, e) {
+  try {
+    const s = $(e.width, t.outerWidth), n = $(
+      e.height,
+      t.outerHeight
+    );
+    t.resizeTo(s, n);
+  } catch {
+  }
+}
+function dt(t) {
+  const { doc: e, dimensions: s, uid: n, tag: i } = t, r = e.createElement("div");
+  return r.id = `forgeframe-container-${n}`, r.setAttribute("data-forgeframe-tag", i), Object.assign(r.style, {
+    display: "inline-block",
+    position: "relative",
+    width: P(s.width),
+    height: P(s.height),
+    overflow: "hidden"
+  }), r;
+}
+function ft(t) {
+  const { doc: e, dimensions: s, cspNonce: n } = t, i = e.createElement("div");
+  Object.assign(i.style, {
+    display: "flex",
+    alignItems: "center",
+    justifyContent: "center",
+    width: P(s.width),
+    height: P(s.height),
+    backgroundColor: "#f5f5f5",
+    position: "absolute",
+    top: "0",
+    left: "0",
+    zIndex: "100"
+  });
+  const r = e.createElement("div");
+  Object.assign(r.style, {
+    width: "40px",
+    height: "40px",
+    border: "3px solid #e0e0e0",
+    borderTopColor: "#3498db",
+    borderRadius: "50%",
+    animation: "forgeframe-spin 1s linear infinite"
+  });
+  const o = e.createElement("style");
+  return n && o.setAttribute("nonce", n), o.textContent = `
+    @keyframes forgeframe-spin {
+      to { transform: rotate(360deg); }
+    }
+  `, i.appendChild(o), i.appendChild(r), i;
+}
+function pt(t, e = 200) {
+  return new Promise((s) => {
+    t.style.opacity = "0", t.style.transition = `opacity ${e}ms ease-in`, t.offsetHeight, t.style.opacity = "1", setTimeout(s, e);
+  });
+}
+function mt(t, e = 200) {
+  return new Promise((s) => {
+    t.style.transition = `opacity ${e}ms ease-out`, t.style.opacity = "0", setTimeout(s, e);
+  });
+}
+async function gt(t, e, s) {
+  e && (await mt(e, 150), e.remove()), s.style.display = "", s.style.visibility = "visible", s.style.opacity = "0", await pt(s, 150);
+}
+class Q {
+  /** Event emitter for lifecycle events. */
+  event;
+  /** Arbitrary state storage for the component instance. */
+  state = {};
+  /** Data exported by the host component. */
+  exports;
+  /** Data exported from the consumer by the host. */
+  consumerExports;
+  /** @internal */
+  _uid;
+  /**
+   * Unique instance identifier.
+   * @readonly
+   */
+  get uid() {
+    return this._uid;
+  }
+  /** @internal */
+  options;
+  /** @internal */
+  props;
+  /** @internal */
+  context;
+  /** @internal */
+  messenger;
+  /** @internal */
+  bridge;
+  /** @internal */
+  cleanup;
+  /** @internal */
+  hostWindow = null;
+  /** @internal */
+  iframe = null;
+  /** @internal */
+  container = null;
+  /** @internal */
+  prerenderElement = null;
+  /** @internal */
+  initPromise = null;
+  /** @internal */
+  rendered = !1;
+  /** @internal */
+  destroyed = !1;
+  /**
+   * Creates a new ConsumerComponent instance.
+   *
+   * @param options - Component configuration options
+   * @param props - Initial props to pass to the component
+   */
+  constructor(e, s = {}) {
+    this._uid = Ie(), this.options = this.normalizeOptions(e), this.context = this.options.defaultContext, this.event = new me(), this.cleanup = new De();
+    const n = this.buildTrustedDomains();
+    this.messenger = new ye(this.uid, window, j(), n), this.bridge = new B(this.messenger);
+    const i = this.createPropContext();
+    this.props = le(s, this.options.props, i), this.setupMessageHandlers(), this.setupCleanup();
+  }
+  /**
+   * Builds the list of trusted domains for messenger communication.
+   * @internal
+   */
+  buildTrustedDomains() {
+    const e = [], s = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url;
+    try {
+      const n = new URL(s);
+      e.push(n.origin);
+    } catch {
+    }
+    if (this.options.domain) {
+      if (typeof this.options.domain == "string")
+        e.push(this.options.domain);
+      else if (Array.isArray(this.options.domain))
+        e.push(...this.options.domain);
+      else if (this.options.domain instanceof RegExp)
+        return this.options.domain;
+    }
+    return e.length > 0 ? e : void 0;
+  }
+  /**
+   * Renders the component into a DOM container.
+   *
+   * @remarks
+   * This is the primary method for displaying the component. It creates
+   * an iframe or popup, establishes communication with the host, and
+   * handles the prerender/render lifecycle.
+   *
+   * @param container - CSS selector or HTMLElement to render into
+   * @param context - Override the default rendering context (iframe or popup)
+   * @throws Error if component was already destroyed or rendered
+   *
+   * @example
+   * ```typescript
+   * await instance.render('#container');
+   * await instance.render(document.getElementById('target'), 'popup');
+   * ```
+   */
+  async render(e, s) {
+    if (this.destroyed)
+      throw new Error("Component has been destroyed");
+    if (this.rendered)
+      throw new Error("Component has already been rendered");
+    this.context = s ?? this.options.defaultContext, this.checkEligibility(), Xe(this.props, this.options.props), this.container = this.resolveContainer(e), this.event.emit(f.PRERENDER), this.callPropCallback("onPrerender"), await this.prerender(), this.event.emit(f.PRERENDERED), this.callPropCallback("onPrerendered"), this.event.emit(f.RENDER), this.callPropCallback("onRender"), await this.open(), await this.waitForHost(), this.context === p.IFRAME && this.iframe && this.prerenderElement && (await gt(
+      this.container,
+      this.prerenderElement,
+      this.iframe
+    ), this.prerenderElement = null), this.rendered = !0, this.event.emit(f.RENDERED), this.callPropCallback("onRendered"), this.event.emit(f.DISPLAY), this.callPropCallback("onDisplay");
+  }
+  /**
+   * Renders the component into a container in a different window.
+   *
+   * @remarks
+   * Currently delegates to regular render. Full cross-window rendering
+   * would require additional complexity.
+   *
+   * @param _win - Target window (currently unused)
+   * @param container - CSS selector or HTMLElement to render into
+   * @param context - Override the default rendering context
+   */
+  async renderTo(e, s, n) {
+    return this.render(s, n);
+  }
+  /**
+   * Closes and destroys the component.
+   *
+   * @remarks
+   * Emits the 'close' event before destruction. Safe to call multiple times.
+   */
+  async close() {
+    this.destroyed || (this.event.emit(f.CLOSE), await this.destroy());
+  }
+  /**
+   * Focuses the component window.
+   *
+   * @remarks
+   * For iframes, focuses the iframe element. For popups, brings the window to front.
+   */
+  async focus() {
+    this.context === p.IFRAME && this.iframe ? it(this.iframe) : this.context === p.POPUP && this.hostWindow && ct(this.hostWindow), this.event.emit(f.FOCUS), this.callPropCallback("onFocus");
+  }
+  /**
+   * Resizes the component to the specified dimensions.
+   *
+   * @param dimensions - New width and height for the component
+   */
+  async resize(e) {
+    this.context === p.IFRAME && this.iframe ? st(this.iframe, e) : this.context === p.POPUP && this.hostWindow && ht(this.hostWindow, e), this.event.emit(f.RESIZE, e), this.callPropCallback("onResize", e);
+  }
+  /**
+   * Shows the component if hidden.
+   *
+   * @remarks
+   * Only applicable to iframe context.
+   */
+  async show() {
+    this.context === p.IFRAME && this.iframe && nt(this.iframe);
+  }
+  /**
+   * Hides the component.
+   *
+   * @remarks
+   * Only applicable to iframe context.
+   */
+  async hide() {
+    this.context === p.IFRAME && this.iframe && fe(this.iframe);
+  }
+  /**
+   * Updates the component props and sends them to the host.
+   *
+   * @remarks
+   * Props are normalized and serialized before being sent to the host window.
+   *
+   * @param newProps - Partial props object to merge with existing props
+   */
+  async updateProps(e) {
+    const s = this.createPropContext();
+    if (this.props = le(
+      { ...this.props, ...e },
+      this.options.props,
+      s
+    ), this.hostWindow && !Ee(this.hostWindow)) {
+      const n = this.getHostDomain(), i = ue(
+        this.props,
+        this.options.props,
+        n,
+        _e(this.hostWindow)
+      ), r = he(
+        i,
+        this.options.props,
+        this.bridge
+      );
+      await this.messenger.send(
+        this.hostWindow,
+        n,
+        u.PROPS,
+        r
+      );
+    }
+    this.event.emit(f.PROPS, this.props), this.callPropCallback("onProps", this.props);
+  }
+  /**
+   * Creates a clone of this instance with the same props.
+   *
+   * @returns A new unrendered component instance with identical configuration
+   */
+  clone() {
+    return new Q(this.options, this.props);
+  }
+  /**
+   * Checks if the component is eligible to render based on the eligible option.
+   *
+   * @returns True if eligible or no eligibility check defined
+   */
+  isEligible() {
+    return this.options.eligible ? this.options.eligible({ props: this.props }).eligible : !0;
+  }
+  /**
+   * Normalizes component options with default values.
+   * @internal
+   */
+  normalizeOptions(e) {
+    return {
+      ...e,
+      props: e.props ?? {},
+      defaultContext: e.defaultContext ?? p.IFRAME,
+      dimensions: typeof e.dimensions == "function" ? e.dimensions(this.props) : e.dimensions ?? { width: "100%", height: "100%" },
+      timeout: e.timeout ?? 1e4,
+      children: e.children
+    };
+  }
+  /**
+   * Creates the prop context passed to prop callbacks and validators.
+   * @internal
+   */
+  createPropContext() {
+    return {
+      props: this.props,
+      state: this.state,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      onError: (e) => this.handleError(e),
+      container: this.container,
+      uid: this.uid,
+      tag: this.options.tag
+    };
+  }
+  /**
+   * Resolves a container selector or element to an HTMLElement.
+   * @internal
+   */
+  resolveContainer(e) {
+    if (!e)
+      throw new Error("Container is required for rendering");
+    if (typeof e == "string") {
+      const s = document.querySelector(e);
+      if (!s)
+        throw new Error(`Container "${e}" not found`);
+      return s;
+    }
+    return e;
+  }
+  /**
+   * Checks eligibility and throws if component cannot render.
+   * @internal
+   */
+  checkEligibility() {
+    if (!this.options.eligible) return;
+    const e = this.options.eligible({ props: this.props });
+    if (!e.eligible)
+      throw new Error(`Component not eligible: ${e.reason ?? "Unknown reason"}`);
+  }
+  /**
+   * Creates and displays the prerender (loading) content.
+   * @internal
+   */
+  async prerender() {
+    if (!this.container) return;
+    const e = this.options.prerenderTemplate ?? ft, s = this.options.containerTemplate ?? dt, n = this.options.dimensions, i = this.props.cspNonce;
+    if (this.context === p.IFRAME) {
+      const c = this.buildWindowName();
+      this.iframe = this.createIframeElement(c), fe(this.iframe);
+    }
+    const r = {
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      dimensions: n,
+      props: this.props,
+      doc: document,
+      container: this.container,
+      frame: this.iframe,
+      prerenderFrame: null,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      cspNonce: i
+    };
+    this.prerenderElement = e(r);
+    const o = {
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      dimensions: n,
+      props: this.props,
+      doc: document,
+      container: this.container,
+      frame: this.iframe,
+      prerenderFrame: this.prerenderElement,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      cspNonce: i
+    }, a = s(o);
+    a && (this.container.appendChild(a), this.container = a), this.prerenderElement && !this.prerenderElement.parentNode && this.container.appendChild(this.prerenderElement), this.iframe && !this.iframe.parentNode && this.container.appendChild(this.iframe);
+  }
+  /**
+   * Creates an iframe element without setting src (for prerender phase).
+   * The window name is set immediately as it carries the payload for the host.
+   * @internal
+   */
+  createIframeElement(e) {
+    const s = document.createElement("iframe"), n = this.options.dimensions, i = typeof this.options.attributes == "function" ? this.options.attributes(this.props) : this.options.attributes ?? {}, r = typeof this.options.style == "function" ? this.options.style(this.props) : this.options.style ?? {};
+    s.name = e, s.setAttribute("frameborder", "0"), s.setAttribute("allowtransparency", "true"), s.setAttribute("scrolling", "auto"), n.width !== void 0 && (s.style.width = typeof n.width == "number" ? `${n.width}px` : n.width), n.height !== void 0 && (s.style.height = typeof n.height == "number" ? `${n.height}px` : n.height);
+    for (const [o, a] of Object.entries(i))
+      a !== void 0 && (typeof a == "boolean" ? a && s.setAttribute(o, "") : s.setAttribute(o, a));
+    for (const [o, a] of Object.entries(r)) {
+      if (a === void 0) continue;
+      const c = typeof a == "number" ? `${a}px` : a;
+      s.style.setProperty(
+        o.replace(/([A-Z])/g, "-$1").toLowerCase(),
+        String(c)
+      );
+    }
+    return i.sandbox || s.setAttribute(
+      "sandbox",
+      "allow-scripts allow-same-origin allow-forms allow-popups allow-popups-to-escape-sandbox"
+    ), s;
+  }
+  /**
+   * Opens the host window (iframe or popup).
+   * @internal
+   */
+  async open() {
+    const e = this.buildUrl();
+    if (this.context === p.IFRAME) {
+      if (!this.iframe)
+        throw new Error("Iframe not created during prerender");
+      this.iframe.src = e, this.hostWindow = this.iframe.contentWindow;
+    } else {
+      const s = this.buildWindowName();
+      this.hostWindow = ot({
+        url: e,
+        name: s,
+        dimensions: this.options.dimensions
+      });
+      const n = ut(this.hostWindow, () => {
+        this.destroy();
+      });
+      this.cleanup.register(n);
+    }
+    this.hostWindow && Be(this.uid, this.hostWindow);
+  }
+  /**
+   * Builds the URL for the host window including query parameters.
+   * @internal
+   */
+  buildUrl() {
+    const e = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url, n = Ye(this.props, this.options.props).toString();
+    if (!n) return e;
+    const i = e.includes("?") ? "&" : "?";
+    return `${e}${i}${n}`;
+  }
+  /**
+   * Builds the window.name payload for the host window.
+   * @internal
+   */
+  buildWindowName() {
+    const e = this.getHostDomain(), s = ue(
+      this.props,
+      this.options.props,
+      e,
+      !1
+      // Assume cross-domain for initial payload
+    ), n = he(
+      s,
+      this.options.props,
+      this.bridge
+    ), i = this.buildNestedHostRefs(), r = Me({
+      uid: this.uid,
+      tag: this.options.tag,
+      context: this.context,
+      consumerDomain: j(),
+      props: n,
+      exports: this.createConsumerExports(),
+      children: i
+    });
+    return He(r);
+  }
+  /**
+   * Builds component references for nested host components.
+   * @internal
+   */
+  buildNestedHostRefs() {
+    if (!this.options.children) return;
+    const e = this.options.children({ props: this.props }), s = {};
+    for (const [n, i] of Object.entries(e)) {
+      const r = i;
+      s[n] = {
+        tag: r.tag ?? n,
+        url: typeof r.url == "function" ? r.url.toString() : r.url ?? ""
+      };
+    }
+    return Object.keys(s).length > 0 ? s : void 0;
+  }
+  /**
+   * Creates the exports object sent to the host.
+   * @internal
+   */
+  createConsumerExports() {
+    return {
+      init: u.INIT,
+      close: u.CLOSE,
+      resize: u.RESIZE,
+      show: u.SHOW,
+      hide: u.HIDE,
+      onError: u.ERROR,
+      updateProps: u.PROPS,
+      export: u.EXPORT
+    };
+  }
+  /**
+   * Extracts the origin domain from the component URL.
+   * @internal
+   */
+  getHostDomain() {
+    const e = typeof this.options.url == "function" ? this.options.url(this.props) : this.options.url;
+    try {
+      return new URL(e, window.location.origin).origin;
+    } catch {
+      return "*";
+    }
+  }
+  /**
+   * Waits for the host to send the init message.
+   * @internal
+   */
+  async waitForHost() {
+    this.initPromise = ge();
+    try {
+      await Ne(
+        this.initPromise.promise,
+        this.options.timeout,
+        `Host component "${this.options.tag}" (uid: ${this._uid}) did not initialize within ${this.options.timeout}ms. Check that the host page loads correctly and calls the initialization code.`
+      );
+    } catch (e) {
+      throw this.handleError(e), e;
+    }
+  }
+  /**
+   * Sets up message handlers for host communication.
+   * @internal
+   */
+  setupMessageHandlers() {
+    this.messenger.on(u.INIT, () => (this.initPromise && this.initPromise.resolve(), { success: !0 })), this.messenger.on(u.CLOSE, async () => (await this.close(), { success: !0 })), this.messenger.on(u.RESIZE, async (e) => (await this.resize(e), { success: !0 })), this.messenger.on(u.FOCUS, async () => (await this.focus(), { success: !0 })), this.messenger.on(u.SHOW, async () => (await this.show(), { success: !0 })), this.messenger.on(u.HIDE, async () => (await this.hide(), { success: !0 })), this.messenger.on(
+      u.ERROR,
+      async (e) => {
+        const s = new Error(e.message);
+        return s.stack = e.stack, this.handleError(s), { success: !0 };
+      }
+    ), this.messenger.on(u.EXPORT, async (e) => (this.exports = e, { success: !0 })), this.messenger.on(u.CONSUMER_EXPORT, async (e) => (this.consumerExports = e, { success: !0 })), this.messenger.on(
+      u.GET_SIBLINGS,
+      async (e) => {
+        const s = [], n = Pt(e.tag);
+        if (n)
+          for (const i of n.instances)
+            i.uid !== e.uid && s.push({
+              uid: i.uid,
+              tag: e.tag,
+              exports: i.exports
+            });
+        return s;
+      }
+    );
+  }
+  /**
+   * Registers cleanup handlers for the instance.
+   * @internal
+   */
+  setupCleanup() {
+    this.cleanup.register(() => {
+      this.messenger.destroy(), this.bridge.destroy(), this.event.removeAllListeners(), Je(this.uid);
+    });
+  }
+  /**
+   * Handles errors by emitting events and calling callbacks.
+   * @internal
+   */
+  handleError(e) {
+    this.event.emit(f.ERROR, e), this.callPropCallback("onError", e);
+  }
+  /**
+   * Calls a prop callback if it exists.
+   * @internal
+   */
+  callPropCallback(e, ...s) {
+    const n = this.props[e];
+    if (typeof n == "function")
+      try {
+        const i = n(...s);
+        i && typeof i == "object" && "catch" in i && typeof i.catch == "function" && i.catch((r) => {
+          console.error(`Error in async ${e} callback:`, r);
+        });
+      } catch (i) {
+        console.error(`Error in ${e} callback:`, i);
+      }
+  }
+  /**
+   * Destroys the component and cleans up all resources.
+   * @internal
+   */
+  async destroy() {
+    this.destroyed || (this.destroyed = !0, this.initPromise && (this.initPromise.reject(
+      new Error(`Component "${this.options.tag}" was destroyed before initialization completed`)
+    ), this.initPromise = null), this.iframe && (tt(this.iframe), this.iframe = null), this.context === p.POPUP && this.hostWindow && at(this.hostWindow), this.hostWindow = null, this.prerenderElement && (this.prerenderElement.remove(), this.prerenderElement = null), await this.cleanup.cleanup(), this.event.emit(f.DESTROY), this.callPropCallback("onDestroy"));
+  }
+}
+class yt {
+  /**
+   * Creates a new HostComponent instance.
+   *
+   * @param payload - The payload parsed from window.name
+   * @param propDefinitions - Optional prop definitions for deserialization
+   */
+  constructor(e, s = {}) {
+    this.propDefinitions = s, this.uid = e.uid, this.tag = e.tag, this.consumerDomain = e.consumerDomain, this.event = new me(), this.messenger = new ye(this.uid, window, j(), this.consumerDomain), this.setupMessageHandlers(), this.consumerWindow = this.resolveConsumerWindow(), this.bridge = new B(this.messenger), this.hostProps = this.buildHostProps(e), window.hostProps = this.hostProps, this.sendInit();
+  }
+  /** The hostProps object containing props and control methods passed from the consumer. */
+  hostProps;
+  /** Event emitter for lifecycle events. */
+  event;
+  /** @internal */
+  uid;
+  /** @internal */
+  tag;
+  /** @internal */
+  consumerWindow;
+  /** @internal */
+  consumerDomain;
+  /** @internal */
+  messenger;
+  /** @internal */
+  bridge;
+  /** @internal */
+  propsHandlers = /* @__PURE__ */ new Set();
+  /** @internal */
+  consumerProps;
+  /** @internal */
+  initError = null;
+  /**
+   * Returns the hostProps object.
+   *
+   * @returns The hostProps object with props and control methods
+   */
+  getProps() {
+    return this.hostProps;
+  }
+  /**
+   * Resolves the consumer window reference (iframe parent or popup opener).
+   * @internal
+   */
+  resolveConsumerWindow() {
+    if (Le()) {
+      const e = Fe();
+      if (e) return e;
+    }
+    if (Ae()) {
+      const e = $e();
+      if (e) return e;
+    }
+    throw new Error("Could not resolve consumer window");
+  }
+  /**
+   * Builds the hostProps object with deserialized props and control methods.
+   * @internal
+   */
+  buildHostProps(e) {
+    const s = de(
+      e.props,
+      this.propDefinitions,
+      this.messenger,
+      this.bridge,
+      this.consumerWindow,
+      this.consumerDomain
+    );
+    return this.consumerProps = s, {
+      ...s,
+      uid: this.uid,
+      tag: this.tag,
+      close: () => this.close(),
+      focus: () => this.focus(),
+      resize: (n) => this.resize(n),
+      show: () => this.show(),
+      hide: () => this.hide(),
+      onProps: (n) => this.onProps(n),
+      onError: (n) => this.onError(n),
+      getConsumer: () => this.consumerWindow,
+      getConsumerDomain: () => this.consumerDomain,
+      export: (n) => this.exportData(n),
+      consumer: {
+        props: this.consumerProps,
+        export: (n) => this.consumerExport(n)
+      },
+      getPeerInstances: (n) => this.getPeerInstances(n),
+      children: this.buildNestedComponents(e.children)
+    };
+  }
+  /**
+   * Sends initialization message to the consumer.
+   * @internal
+   */
+  async sendInit() {
+    try {
+      await this.messenger.send(
+        this.consumerWindow,
+        this.consumerDomain,
+        u.INIT,
+        { uid: this.uid, tag: this.tag }
+      );
+    } catch (e) {
+      const s = e instanceof Error ? e : new Error(String(e));
+      this.initError = s, this.event.emit(f.ERROR, {
+        type: "init_failed",
+        message: `Failed to initialize host component: ${s.message}`,
+        error: s
+      }), console.error("Failed to send init message:", e);
+    }
+  }
+  /**
+   * Returns the initialization error if one occurred.
+   *
+   * @returns The initialization error or null if successful
+   */
+  getInitError() {
+    return this.initError;
+  }
+  /**
+   * Requests the consumer to close this component.
+   * @internal
+   */
+  async close() {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.CLOSE,
+      {}
+    );
+  }
+  /**
+   * Focuses this window and notifies the consumer.
+   * @internal
+   */
+  async focus() {
+    window.focus(), await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.FOCUS,
+      {}
+    );
+  }
+  /**
+   * Requests the consumer to resize this component.
+   * @internal
+   */
+  async resize(e) {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.RESIZE,
+      e
+    );
+  }
+  /**
+   * Requests the consumer to show this component.
+   * @internal
+   */
+  async show() {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.SHOW,
+      {}
+    );
+  }
+  /**
+   * Requests the consumer to hide this component.
+   * @internal
+   */
+  async hide() {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.HIDE,
+      {}
+    );
+  }
+  /**
+   * Subscribes to prop updates from the consumer.
+   * @internal
+   */
+  onProps(e) {
+    return this.propsHandlers.add(e), {
+      cancel: () => this.propsHandlers.delete(e)
+    };
+  }
+  /**
+   * Reports an error to the consumer.
+   * @internal
+   */
+  async onError(e) {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.ERROR,
+      {
+        message: e.message,
+        stack: e.stack
+      }
+    );
+  }
+  /**
+   * Exports data or methods to the consumer.
+   * @internal
+   */
+  async exportData(e) {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.EXPORT,
+      e
+    );
+  }
+  /**
+   * Exports data to the consumer for bidirectional communication.
+   * @internal
+   */
+  async consumerExport(e) {
+    await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.CONSUMER_EXPORT,
+      e
+    );
+  }
+  /**
+   * Gets information about peer component instances.
+   * @internal
+   */
+  async getPeerInstances(e) {
+    return await this.messenger.send(
+      this.consumerWindow,
+      this.consumerDomain,
+      u.GET_SIBLINGS,
+      { uid: this.uid, tag: this.tag, options: e }
+    ) ?? [];
+  }
+  /**
+   * Builds nested component factories from refs passed by the consumer.
+   * @internal
+   */
+  buildNestedComponents(e) {
+    if (!e) return;
+    const s = {};
+    for (const [n, i] of Object.entries(e))
+      try {
+        s[n] = Se({
+          tag: i.tag,
+          url: i.url,
+          props: i.props,
+          dimensions: i.dimensions,
+          defaultContext: i.defaultContext
+        });
+      } catch (r) {
+        console.warn(`Failed to create nested component "${n}":`, r);
+      }
+    return Object.keys(s).length > 0 ? s : void 0;
+  }
+  /**
+   * Sets up message handlers for consumer communication.
+   * @internal
+   */
+  setupMessageHandlers() {
+    this.messenger.on(u.PROPS, (e) => {
+      try {
+        const s = de(
+          e,
+          this.propDefinitions,
+          this.messenger,
+          this.bridge,
+          this.consumerWindow,
+          this.consumerDomain
+        );
+        Object.assign(this.hostProps, s);
+        for (const n of this.propsHandlers)
+          try {
+            n(s);
+          } catch (i) {
+            console.error("Error in props handler:", i);
+          }
+        return this.event.emit(f.PROPS, s), { success: !0 };
+      } catch (s) {
+        const n = s instanceof Error ? s : new Error(String(s));
+        throw console.error("Error deserializing props:", n), this.event.emit(f.ERROR, n), n;
+      }
+    });
+  }
+  /**
+   * Destroys the host component and cleans up resources.
+   */
+  destroy() {
+    this.messenger.destroy(), this.bridge.destroy(), this.event.removeAllListeners(), this.propsHandlers.clear();
+  }
+}
+let v = null;
+function xe(t) {
+  if (v)
+    return v;
+  if (!J())
+    return null;
+  const e = Ue();
+  return e ? (v = new yt(
+    e,
+    t
+  ), v) : (console.error("Failed to parse ForgeFrame payload from window.name"), null);
+}
+function _t() {
+  return J();
+}
+function wt() {
+  return J();
+}
+function Et() {
+  return window.hostProps;
+}
+const S = /* @__PURE__ */ new Map();
+function bt(t) {
+  if (!t.tag)
+    throw new Error("Component tag is required");
+  if (!/^[a-z][a-z0-9-]*$/.test(t.tag))
+    throw new Error(
+      `Invalid component tag "${t.tag}". Must start with lowercase letter and contain only lowercase letters, numbers, and hyphens.`
+    );
+  if (!t.url)
+    throw new Error("Component url is required");
+  if (typeof t.url == "string")
+    try {
+      new URL(t.url, window.location.origin);
+    } catch {
+      throw new Error(
+        `Invalid component URL "${t.url}". Must be a valid absolute or relative URL.`
+      );
+    }
+  if (S.has(t.tag))
+    throw new Error(`Component "${t.tag}" is already registered`);
+}
+function Se(t) {
+  bt(t);
+  const e = [];
+  let s;
+  if (H(t.tag)) {
+    const i = xe(t.props);
+    i && (s = i.hostProps);
+  }
+  const n = function(i = {}) {
+    const r = new Q(t, i);
+    return e.push(r), r.event.once("destroy", () => {
+      const o = e.indexOf(r);
+      o !== -1 && e.splice(o, 1);
+    }), r;
+  };
+  return n.instances = e, n.isHost = () => H(t.tag), n.isEmbedded = () => H(t.tag), n.hostProps = s, n.canRenderTo = async (i) => {
+    try {
+      return !!(_e(i) || t.domain);
+    } catch {
+      return !1;
+    }
+  }, S.set(t.tag, n), n;
+}
+function Pt(t) {
+  return S.get(t);
+}
+async function Rt(t) {
+  await t.close();
+}
+async function Oe(t) {
+  const e = S.get(t);
+  if (!e) return;
+  const s = [...e.instances];
+  await Promise.all(s.map((n) => n.close()));
+}
+async function xt() {
+  const t = Array.from(S.keys());
+  await Promise.all(t.map((e) => Oe(e)));
+}
+function St(t, e) {
+  const { React: s } = e, { createElement: n, useRef: i, useEffect: r, useState: o, forwardRef: a } = s, c = a(
+    function(g, y) {
+      const {
+        onRendered: b,
+        onError: O,
+        onClose: ee,
+        context: Ce,
+        className: te,
+        style: se,
+        ...F
+      } = g, C = i(null), L = i(null), [ne, ve] = o(null);
+      return r(() => {
+        const x = C.current;
+        if (!x) return;
+        const _ = t(F);
+        return L.current = _, b && _.event.once("rendered", b), ee && _.event.once("close", ee), O && _.event.on("error", O), _.render(x, Ce).catch((ie) => {
+          ve(ie), O?.(ie);
+        }), () => {
+          _.close().catch(() => {
+          }), L.current = null;
+        };
+      }, []), r(() => {
+        const x = L.current;
+        x && x.updateProps(F).catch((_) => {
+          O?.(_);
+        });
+      }, [JSON.stringify(F)]), r(() => {
+        y && typeof y == "object" && C.current && (y.current = C.current);
+      }, [y]), ne ? n(
+        "div",
+        {
+          className: te,
+          style: { color: "red", padding: "16px", ...se }
+        },
+        `Error: ${ne.message}`
+      ) : n("div", {
+        ref: C,
+        className: te,
+        style: {
+          display: "inline-block",
+          ...se
+        }
+      });
+    }
+  ), l = `ForgeFrame(${t.name || "Component"})`;
+  return c.displayName = l, c;
+}
+function Ot(t) {
+  return function(s) {
+    return St(s, { React: t });
+  };
+}
+xe();
+const Ct = {
+  /**
+   * Create a new component definition.
+   *
+   * @remarks
+   * This is the main entry point for defining components. Returns a
+   * component factory function that can be called to create instances.
+   *
+   * @example
+   * ```typescript
+   * import ForgeFrame, { prop } from 'forgeframe';
+   *
+   * const MyComponent = ForgeFrame.create({
+   *   tag: 'my-component',
+   *   url: 'https://example.com/component',
+   *   props: {
+   *     email: prop.string().email(),
+   *     onLogin: prop.function<(user: { id: string }) => void>(),
+   *   },
+   * });
+   *
+   * const instance = MyComponent({ email: 'user@example.com', onLogin: (user) => {} });
+   * await instance.render('#container');
+   * ```
+   */
+  create: Se,
+  /**
+   * Destroy a single component instance.
+   *
+   * @param instance - The component instance to destroy
+   */
+  destroy: Rt,
+  /**
+   * Destroy all instances of a specific component by tag.
+   *
+   * @param tag - The component tag name
+   */
+  destroyByTag: Oe,
+  /**
+   * Destroy all ForgeFrame component instances.
+   */
+  destroyAll: xt,
+  /**
+   * Check if the current window is a host component context.
+   *
+   * @remarks
+   * A "host" is the embedded iframe or popup window that receives props
+   * from the consumer (the embedding app).
+   *
+   * @returns True if running inside a ForgeFrame iframe/popup
+   */
+  isHost: _t,
+  /**
+   * Check if the current window is embedded by ForgeFrame.
+   *
+   * @remarks
+   * This is an alias for {@link isHost} that uses more intuitive terminology.
+   *
+   * @returns True if running inside a ForgeFrame iframe/popup
+   */
+  isEmbedded: wt,
+  /**
+   * Get hostProps from the current host window.
+   *
+   * @remarks
+   * Returns the props passed from the consumer plus built-in control methods.
+   *
+   * @returns The hostProps object if in host context, undefined otherwise
+   */
+  getHostProps: Et,
+  /**
+   * Serialization strategy constants.
+   * @see {@link PROP_SERIALIZATION}
+   */
+  PROP_SERIALIZATION: I,
+  /**
+   * Rendering context constants (IFRAME, POPUP).
+   * @see {@link CONTEXT}
+   */
+  CONTEXT: p,
+  /**
+   * Lifecycle event name constants.
+   * @see {@link EVENT}
+   */
+  EVENT: f,
+  /**
+   * Error thrown when popup window fails to open.
+   */
+  PopupOpenError: Re,
+  /**
+   * Current library version.
+   */
+  VERSION: pe,
+  /**
+   * Check if a value is a Standard Schema (Zod, Valibot, ArkType, etc.)
+   *
+   * @param value - The value to check
+   * @returns True if the value implements StandardSchemaV1
+   *
+   * @example
+   * ```typescript
+   * import { z } from 'zod';
+   *
+   * const schema = z.string();
+   * if (ForgeFrame.isStandardSchema(schema)) {
+   *   // schema is StandardSchemaV1
+   * }
+   * ```
+   */
+  isStandardSchema: E,
+  /**
+   * Prop schema builders for defining component props.
+   *
+   * @remarks
+   * Provides a fluent, Zod-like API for defining prop schemas with built-in
+   * validation. All schemas implement StandardSchemaV1.
+   *
+   * @example
+   * ```typescript
+   * import ForgeFrame from 'forgeframe';
+   *
+   * const Component = ForgeFrame.create({
+   *   tag: 'my-component',
+   *   url: '/component',
+   *   props: {
+   *     name: ForgeFrame.prop.string(),
+   *     count: ForgeFrame.prop.number().default(0),
+   *     onSubmit: ForgeFrame.prop.function().optional(),
+   *   },
+   * });
+   * ```
+   */
+  prop: d
+};
+export {
+  K as AnySchema,
+  T as ArraySchema,
+  X as BooleanSchema,
+  p as CONTEXT,
+  f as EVENT,
+  G as EnumSchema,
+  Ct as ForgeFrame,
+  Y as FunctionSchema,
+  Z as LiteralSchema,
+  q as NumberSchema,
+  k as ObjectSchema,
+  I as PROP_SERIALIZATION,
+  Re as PopupOpenError,
+  m as PropSchema,
+  V as StringSchema,
+  pe as VERSION,
+  Se as create,
+  St as createReactComponent,
+  Ct as default,
+  Rt as destroy,
+  xt as destroyAll,
+  Oe as destroyByTag,
+  Et as getHostProps,
+  wt as isEmbedded,
+  _t as isHost,
+  E as isStandardSchema,
+  d as prop,
+  Ot as withReactComponent
+};