@adobe/uix-guest 0.6.5 → 0.7.1-nightly.20230114

package/dist/iife/index.js

@@ -30,6 +30,206 @@ var AdobeUIXGuest = (() => {
   var require_dist = __commonJS({
     "../uix-core/dist/index.js"(exports) {
       "use strict";
+      var __create2 = Object.create;
+      var __defProp2 = Object.defineProperty;
+      var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+      var __getOwnPropNames2 = Object.getOwnPropertyNames;
+      var __getProtoOf2 = Object.getPrototypeOf;
+      var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+      var __commonJS2 = (cb, mod) => function __require() {
+        return mod || (0, cb[__getOwnPropNames2(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+      };
+      var __copyProps2 = (to, from, except, desc) => {
+        if (from && typeof from === "object" || typeof from === "function") {
+          for (let key of __getOwnPropNames2(from))
+            if (!__hasOwnProp2.call(to, key) && key !== except)
+              __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+        }
+        return to;
+      };
+      var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+        isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+        mod
+      ));
+      var require_eventemitter3 = __commonJS2({
+        "../../node_modules/eventemitter3/index.js"(exports2, module2) {
+          var has = Object.prototype.hasOwnProperty;
+          var prefix = "~";
+          function Events() {
+          }
+          if (Object.create) {
+            Events.prototype = /* @__PURE__ */ Object.create(null);
+            if (!new Events().__proto__)
+              prefix = false;
+          }
+          function EE(fn, context, once) {
+            this.fn = fn;
+            this.context = context;
+            this.once = once || false;
+          }
+          function addListener(emitter, event, fn, context, once) {
+            if (typeof fn !== "function") {
+              throw new TypeError("The listener must be a function");
+            }
+            var listener = new EE(fn, context || emitter, once), evt = prefix ? prefix + event : event;
+            if (!emitter._events[evt])
+              emitter._events[evt] = listener, emitter._eventsCount++;
+            else if (!emitter._events[evt].fn)
+              emitter._events[evt].push(listener);
+            else
+              emitter._events[evt] = [emitter._events[evt], listener];
+            return emitter;
+          }
+          function clearEvent(emitter, evt) {
+            if (--emitter._eventsCount === 0)
+              emitter._events = new Events();
+            else
+              delete emitter._events[evt];
+          }
+          function EventEmitter2() {
+            this._events = new Events();
+            this._eventsCount = 0;
+          }
+          EventEmitter2.prototype.eventNames = function eventNames() {
+            var names = [], events, name;
+            if (this._eventsCount === 0)
+              return names;
+            for (name in events = this._events) {
+              if (has.call(events, name))
+                names.push(prefix ? name.slice(1) : name);
+            }
+            if (Object.getOwnPropertySymbols) {
+              return names.concat(Object.getOwnPropertySymbols(events));
+            }
+            return names;
+          };
+          EventEmitter2.prototype.listeners = function listeners(event) {
+            var evt = prefix ? prefix + event : event, handlers = this._events[evt];
+            if (!handlers)
+              return [];
+            if (handlers.fn)
+              return [handlers.fn];
+            for (var i = 0, l = handlers.length, ee = new Array(l); i < l; i++) {
+              ee[i] = handlers[i].fn;
+            }
+            return ee;
+          };
+          EventEmitter2.prototype.listenerCount = function listenerCount(event) {
+            var evt = prefix ? prefix + event : event, listeners = this._events[evt];
+            if (!listeners)
+              return 0;
+            if (listeners.fn)
+              return 1;
+            return listeners.length;
+          };
+          EventEmitter2.prototype.emit = function emit(event, a1, a2, a3, a4, a5) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt])
+              return false;
+            var listeners = this._events[evt], len = arguments.length, args, i;
+            if (listeners.fn) {
+              if (listeners.once)
+                this.removeListener(event, listeners.fn, void 0, true);
+              switch (len) {
+                case 1:
+                  return listeners.fn.call(listeners.context), true;
+                case 2:
+                  return listeners.fn.call(listeners.context, a1), true;
+                case 3:
+                  return listeners.fn.call(listeners.context, a1, a2), true;
+                case 4:
+                  return listeners.fn.call(listeners.context, a1, a2, a3), true;
+                case 5:
+                  return listeners.fn.call(listeners.context, a1, a2, a3, a4), true;
+                case 6:
+                  return listeners.fn.call(listeners.context, a1, a2, a3, a4, a5), true;
+              }
+              for (i = 1, args = new Array(len - 1); i < len; i++) {
+                args[i - 1] = arguments[i];
+              }
+              listeners.fn.apply(listeners.context, args);
+            } else {
+              var length = listeners.length, j;
+              for (i = 0; i < length; i++) {
+                if (listeners[i].once)
+                  this.removeListener(event, listeners[i].fn, void 0, true);
+                switch (len) {
+                  case 1:
+                    listeners[i].fn.call(listeners[i].context);
+                    break;
+                  case 2:
+                    listeners[i].fn.call(listeners[i].context, a1);
+                    break;
+                  case 3:
+                    listeners[i].fn.call(listeners[i].context, a1, a2);
+                    break;
+                  case 4:
+                    listeners[i].fn.call(listeners[i].context, a1, a2, a3);
+                    break;
+                  default:
+                    if (!args)
+                      for (j = 1, args = new Array(len - 1); j < len; j++) {
+                        args[j - 1] = arguments[j];
+                      }
+                    listeners[i].fn.apply(listeners[i].context, args);
+                }
+              }
+            }
+            return true;
+          };
+          EventEmitter2.prototype.on = function on(event, fn, context) {
+            return addListener(this, event, fn, context, false);
+          };
+          EventEmitter2.prototype.once = function once(event, fn, context) {
+            return addListener(this, event, fn, context, true);
+          };
+          EventEmitter2.prototype.removeListener = function removeListener(event, fn, context, once) {
+            var evt = prefix ? prefix + event : event;
+            if (!this._events[evt])
+              return this;
+            if (!fn) {
+              clearEvent(this, evt);
+              return this;
+            }
+            var listeners = this._events[evt];
+            if (listeners.fn) {
+              if (listeners.fn === fn && (!once || listeners.once) && (!context || listeners.context === context)) {
+                clearEvent(this, evt);
+              }
+            } else {
+              for (var i = 0, events = [], length = listeners.length; i < length; i++) {
+                if (listeners[i].fn !== fn || once && !listeners[i].once || context && listeners[i].context !== context) {
+                  events.push(listeners[i]);
+                }
+              }
+              if (events.length)
+                this._events[evt] = events.length === 1 ? events[0] : events;
+              else
+                clearEvent(this, evt);
+            }
+            return this;
+          };
+          EventEmitter2.prototype.removeAllListeners = function removeAllListeners(event) {
+            var evt;
+            if (event) {
+              evt = prefix ? prefix + event : event;
+              if (this._events[evt])
+                clearEvent(this, evt);
+            } else {
+              this._events = new Events();
+              this._eventsCount = 0;
+            }
+            return this;
+          };
+          EventEmitter2.prototype.off = EventEmitter2.prototype.removeListener;
+          EventEmitter2.prototype.addListener = EventEmitter2.prototype.on;
+          EventEmitter2.prefixed = prefix;
+          EventEmitter2.EventEmitter = EventEmitter2;
+          if ("undefined" !== typeof module2) {
+            module2.exports = EventEmitter2;
+          }
+        }
+      });
       var isDarkMode = () => typeof window.matchMedia === "function" && window.matchMedia("(prefers-color-scheme: dark)").matches;
       var Layouts = {
         medium: {
@@ -219,9 +419,9 @@ var AdobeUIXGuest = (() => {
         return logger;
       }
       var Emitter2 = class extends EventTarget {
-        constructor(id2) {
+        constructor(id) {
           super();
-          this.id = id2;
+          this.id = id;
         }
         emit(type, detail) {
           const event = new CustomEvent(type, { detail });
@@ -264,382 +464,706 @@ var AdobeUIXGuest = (() => {
           }
         });
       }
-      function timeoutPromise2(timeoutMs, promise) {
-        return new Promise((resolve, reject) => {
-          const timeout = setTimeout(
-            () => reject(new Error(`Timed out after ${timeoutMs}ms`)),
-            timeoutMs
-          );
-          promise.then((result) => {
-            clearTimeout(timeout);
-            resolve(result);
-          }).catch(reject);
-        });
+      var NS_ROOT = "_$pg";
+      var VERSION = "0.7.0";
+      var INIT_CALLBACK = `${NS_ROOT}_init_cb`;
+      function isPlainObject(value) {
+        if (!value || typeof value !== "object") {
+          return false;
+        }
+        const proto = Reflect.getPrototypeOf(value);
+        return proto === null || proto === Object.prototype;
       }
-      exports.Emitter = Emitter2;
-      exports._customConsole = _customConsole;
-      exports.debugEmitter = debugEmitter2;
-      exports.makeNamespaceProxy = makeNamespaceProxy2;
-      exports.quietConsole = quietConsole2;
-      exports.timeoutPromise = timeoutPromise2;
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    GuestServer: () => GuestServer,
-    GuestUI: () => GuestUI,
-    PrimaryGuest: () => GuestServer,
-    UIGuest: () => GuestUI,
-    attach: () => attach,
-    createGuest: () => createGuest,
-    register: () => register
-  });
-
-  // ../../node_modules/penpal/lib/enums.js
-  var MessageType;
-  (function(MessageType2) {
-    MessageType2["Call"] = "call";
-    MessageType2["Reply"] = "reply";
-    MessageType2["Syn"] = "syn";
-    MessageType2["SynAck"] = "synAck";
-    MessageType2["Ack"] = "ack";
-  })(MessageType || (MessageType = {}));
-  var Resolution;
-  (function(Resolution2) {
-    Resolution2["Fulfilled"] = "fulfilled";
-    Resolution2["Rejected"] = "rejected";
-  })(Resolution || (Resolution = {}));
-  var ErrorCode;
-  (function(ErrorCode2) {
-    ErrorCode2["ConnectionDestroyed"] = "ConnectionDestroyed";
-    ErrorCode2["ConnectionTimeout"] = "ConnectionTimeout";
-    ErrorCode2["NoIframeSrc"] = "NoIframeSrc";
-  })(ErrorCode || (ErrorCode = {}));
-  var NativeErrorName;
-  (function(NativeErrorName2) {
-    NativeErrorName2["DataCloneError"] = "DataCloneError";
-  })(NativeErrorName || (NativeErrorName = {}));
-  var NativeEventType;
-  (function(NativeEventType2) {
-    NativeEventType2["Message"] = "message";
-  })(NativeEventType || (NativeEventType = {}));
-
-  // ../../node_modules/penpal/lib/createDestructor.js
-  var createDestructor_default = (localName, log) => {
-    const callbacks = [];
-    let destroyed = false;
-    return {
-      destroy(error) {
-        if (!destroyed) {
-          destroyed = true;
-          log(`${localName}: Destroying connection`);
-          callbacks.forEach((callback) => {
-            callback(error);
-          });
+      function isPrimitive(value) {
+        if (!value) {
+          return true;
         }
-      },
-      onDestroy(callback) {
-        destroyed ? callback() : callbacks.push(callback);
+        const theType = typeof value;
+        return theType === "string" || theType === "number" || theType === "boolean";
       }
-    };
-  };
-
-  // ../../node_modules/penpal/lib/createLogger.js
-  var createLogger_default = (debug) => {
-    return (...args) => {
-      if (debug) {
-        console.log("[Penpal]", ...args);
+      function isIterable(value) {
+        return Array.isArray(value);
       }
-    };
-  };
-
-  // ../../node_modules/penpal/lib/errorSerialization.js
-  var serializeError = ({ name, message, stack }) => ({
-    name,
-    message,
-    stack
-  });
-  var deserializeError = (obj) => {
-    const deserializedError = new Error();
-    Object.keys(obj).forEach((key) => deserializedError[key] = obj[key]);
-    return deserializedError;
-  };
-
-  // ../../node_modules/penpal/lib/connectCallReceiver.js
-  var connectCallReceiver_default = (info, serializedMethods, log) => {
-    const { localName, local, remote, originForSending, originForReceiving } = info;
-    let destroyed = false;
-    const handleMessageEvent = (event) => {
-      if (event.source !== remote || event.data.penpal !== MessageType.Call) {
-        return;
+      function hasProp(value, prop) {
+        return !isPrimitive(value) && Reflect.has(value, prop);
       }
-      if (originForReceiving !== "*" && event.origin !== originForReceiving) {
-        log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
-        return;
+      function isIframe(value) {
+        if (!value || isPrimitive(value)) {
+          return false;
+        }
+        const { nodeName } = value;
+        return typeof nodeName === "string" && nodeName.toLowerCase() === "iframe";
+      }
+      function isObjectWithPrototype(value) {
+        if (!value || typeof value !== "object") {
+          return false;
+        }
+        const proto = Reflect.getPrototypeOf(value);
+        return proto !== Object.prototype;
+      }
+      function wrap(message) {
+        return { [NS_ROOT]: message };
+      }
+      function unwrap(wrappedMessage) {
+        return wrappedMessage[NS_ROOT];
       }
-      const callMessage = event.data;
-      const { methodName, args, id: id2 } = callMessage;
-      log(`${localName}: Received ${methodName}() call`);
-      const createPromiseHandler = (resolution) => {
-        return (returnValue) => {
-          log(`${localName}: Sending ${methodName}() reply`);
-          if (destroyed) {
-            log(`${localName}: Unable to send ${methodName}() reply due to destroyed connection`);
-            return;
-          }
-          const message = {
-            penpal: MessageType.Reply,
-            id: id2,
-            resolution,
-            returnValue
+      function isWrapped(item) {
+        if (!isPlainObject(item)) {
+          return false;
+        }
+        const keys = Object.keys(item);
+        const hasRoot = keys.includes(NS_ROOT);
+        if (hasRoot && keys.length != 1) {
+          console.error(
+            `malformed tunnel message, should have one prop "${NS_ROOT}" at root`,
+            item
+          );
+          return false;
+        }
+        return hasRoot;
+      }
+      var NOT_TRANSFORMED = Symbol.for("NOT_TRANSFORMED");
+      var CIRCULAR = "[[Circular]]";
+      function transformRecursive(transform, value, parent, _refs = /* @__PURE__ */ new WeakSet()) {
+        if (isPrimitive(value)) {
+          return value;
+        }
+        const transformed = transform(value, parent);
+        if (transformed !== NOT_TRANSFORMED) {
+          return transformed;
+        }
+        if (isIterable(value)) {
+          const outArray = [];
+          for (const item of value) {
+            outArray.push(transformRecursive(transform, item, void 0, _refs));
+          }
+          return outArray;
+        }
+        if (isPlainObject(value)) {
+          if (_refs.has(value)) {
+            return CIRCULAR;
+          }
+          _refs.add(value);
+          const outObj = {};
+          for (const key of Reflect.ownKeys(value)) {
+            Reflect.set(
+              outObj,
+              key,
+              transformRecursive(transform, Reflect.get(value, key), void 0, _refs)
+            );
+          }
+          return outObj;
+        }
+        if (isObjectWithPrototype(value)) {
+          if (_refs.has(value)) {
+            return CIRCULAR;
+          }
+          _refs.add(value);
+          const getObjectKeys = (obj) => {
+            const result = /* @__PURE__ */ new Set();
+            do {
+              if (Reflect.getPrototypeOf(obj) !== null) {
+                for (const prop of Object.getOwnPropertyNames(obj)) {
+                  if (prop === "constructor") {
+                    continue;
+                  }
+                  result.add(prop);
+                }
+              }
+            } while (obj = Reflect.getPrototypeOf(obj));
+            return [...result];
           };
-          if (resolution === Resolution.Rejected && returnValue instanceof Error) {
-            message.returnValue = serializeError(returnValue);
-            message.returnValueIsError = true;
+          const outObj = {};
+          const properties = getObjectKeys(value);
+          for (const key of properties) {
+            Reflect.set(
+              outObj,
+              key,
+              transformRecursive(transform, Reflect.get(value, key), value, _refs)
+            );
           }
+          return outObj;
+        }
+        throw new Error(`Bad value! ${Object.prototype.toString.call(value)}`);
+      }
+      function receiveCalls(fn, ticket, remote) {
+        const responder = async ({ fnId, callId, args }) => {
           try {
-            remote.postMessage(message, originForSending);
-          } catch (err) {
-            if (err.name === NativeErrorName.DataCloneError) {
-              const errorReplyMessage = {
-                penpal: MessageType.Reply,
-                id: id2,
-                resolution: Resolution.Rejected,
-                returnValue: serializeError(err),
-                returnValueIsError: true
-              };
-              remote.postMessage(errorReplyMessage, originForSending);
-            }
-            throw err;
+            const value = await fn(...args);
+            remote.deref().respond({
+              fnId,
+              callId,
+              value,
+              status: "resolve"
+            });
+          } catch (error) {
+            remote.deref().respond({
+              fnId,
+              callId,
+              status: "reject",
+              error
+            });
           }
         };
-      };
-      new Promise((resolve) => resolve(serializedMethods[methodName].apply(serializedMethods, args))).then(createPromiseHandler(Resolution.Fulfilled), createPromiseHandler(Resolution.Rejected));
-    };
-    local.addEventListener(NativeEventType.Message, handleMessageEvent);
-    return () => {
-      destroyed = true;
-      local.removeEventListener(NativeEventType.Message, handleMessageEvent);
-    };
-  };
-
-  // ../../node_modules/penpal/lib/generateId.js
-  var id = 0;
-  var generateId_default = () => ++id;
-
-  // ../../node_modules/penpal/lib/methodSerialization.js
-  var KEY_PATH_DELIMITER = ".";
-  var keyPathToSegments = (keyPath) => keyPath ? keyPath.split(KEY_PATH_DELIMITER) : [];
-  var segmentsToKeyPath = (segments) => segments.join(KEY_PATH_DELIMITER);
-  var createKeyPath = (key, prefix) => {
-    const segments = keyPathToSegments(prefix || "");
-    segments.push(key);
-    return segmentsToKeyPath(segments);
-  };
-  var setAtKeyPath = (subject, keyPath, value) => {
-    const segments = keyPathToSegments(keyPath);
-    segments.reduce((prevSubject, key, idx) => {
-      if (typeof prevSubject[key] === "undefined") {
-        prevSubject[key] = {};
+        return remote.deref().onCall(ticket, responder);
       }
-      if (idx === segments.length - 1) {
-        prevSubject[key] = value;
+      var DisconnectionError = class extends Error {
+        constructor() {
+          super(
+            "Function belongs to a simulated remote object which has been disconnected! The tunnel may have been destroyed by page navigation or reload."
+          );
+        }
+      };
+      function dispatch(subject, callTicket, rejectionPool, resolve, reject) {
+        subject.onRespond(callTicket, (responseTicket) => {
+          rejectionPool.delete(reject);
+          if (responseTicket.status === "resolve") {
+            resolve(responseTicket.value);
+          } else {
+            reject(responseTicket.error);
+          }
+        });
+        subject.send(callTicket);
       }
-      return prevSubject[key];
-    }, subject);
-    return subject;
-  };
-  var serializeMethods = (methods, prefix) => {
-    const flattenedMethods = {};
-    Object.keys(methods).forEach((key) => {
-      const value = methods[key];
-      const keyPath = createKeyPath(key, prefix);
-      if (typeof value === "object") {
-        Object.assign(flattenedMethods, serializeMethods(value, keyPath));
+      function makeCallSender({ fnId }, subjectRef) {
+        let callCounter = 0;
+        const rejectionPool = /* @__PURE__ */ new Set();
+        let sender = function(...args) {
+          return new Promise((resolve, reject) => {
+            rejectionPool.add(reject);
+            const callId = ++callCounter;
+            const callTicket = {
+              fnId,
+              callId,
+              args
+            };
+            return dispatch(
+              subjectRef.deref(),
+              callTicket,
+              rejectionPool,
+              resolve,
+              reject
+            );
+          });
+        };
+        const destroy = () => {
+          subjectRef = null;
+          sender = () => {
+            throw new DisconnectionError();
+          };
+          for (const reject of rejectionPool) {
+            reject(new DisconnectionError());
+          }
+          rejectionPool.clear();
+        };
+        subjectRef.deref().onDestroyed(destroy);
+        const facade = async function(...args) {
+          return sender(...args);
+        };
+        Object.defineProperty(facade, "name", { value: fnId });
+        return facade;
       }
-      if (typeof value === "function") {
-        flattenedMethods[keyPath] = value;
+      var RemoteSubject = class {
+        constructor(emitter, simulator) {
+          this.emitter = emitter;
+          this.simulator = simulator;
+        }
+        notifyCleanup(ticket) {
+          return this.emitter.emit(`${ticket.fnId}_g`, {});
+        }
+        notifyConnect() {
+          return this.emitter.emit("connected");
+        }
+        notifyDestroy() {
+          return this.emitter.emit("destroyed");
+        }
+        onCall(ticket, handler) {
+          return this.subscribe(
+            `${ticket.fnId}_c`,
+            (ticket2) => handler(this.processCallTicket(ticket2, this.simulator.materialize))
+          );
+        }
+        onConnected(handler) {
+          return this.subscribe("connected", handler);
+        }
+        onDestroyed(handler) {
+          return this.subscribe("destroyed", handler);
+        }
+        onOutOfScope(ticket, handler) {
+          return this.subscribeOnce(`${ticket.fnId}_g`, handler);
+        }
+        onRespond(ticket, handler) {
+          const fnAndCall = `${ticket.fnId}${ticket.callId}`;
+          return this.subscribeOnce(
+            `${fnAndCall}_r`,
+            (ticket2) => handler(this.processResponseTicket(ticket2, this.simulator.materialize))
+          );
+        }
+        respond(ticket) {
+          const fnAndCall = `${ticket.fnId}${ticket.callId}`;
+          return this.emitter.emit(
+            `${fnAndCall}_r`,
+            this.processResponseTicket(ticket, this.simulator.simulate)
+          );
+        }
+        send(ticket) {
+          return this.emitter.emit(
+            `${ticket.fnId}_c`,
+            this.processCallTicket(ticket, this.simulator.simulate)
+          );
+        }
+        processCallTicket({ args, ...ticket }, mapper) {
+          return {
+            ...ticket,
+            args: args.map(mapper)
+          };
+        }
+        processResponseTicket(ticket, mapper) {
+          return ticket.status === "resolve" ? { ...ticket, value: mapper(ticket.value) } : ticket;
+        }
+        subscribe(type, handler) {
+          this.emitter.on(type, handler);
+          return () => {
+            this.emitter.off(type, handler);
+          };
+        }
+        subscribeOnce(type, handler) {
+          const once = (arg) => {
+            this.emitter.off(type, once);
+            handler(arg);
+          };
+          return this.subscribe(type, once);
+        }
+      };
+      function isDefMessage(value) {
+        return isWrapped(value) && hasProp(unwrap(value), "fnId");
       }
-    });
-    return flattenedMethods;
-  };
-  var deserializeMethods = (flattenedMethods) => {
-    const methods = {};
-    for (const keyPath in flattenedMethods) {
-      setAtKeyPath(methods, keyPath, flattenedMethods[keyPath]);
-    }
-    return methods;
-  };
-
-  // ../../node_modules/penpal/lib/connectCallSender.js
-  var connectCallSender_default = (callSender, info, methodKeyPaths, destroyConnection, log) => {
-    const { localName, local, remote, originForSending, originForReceiving } = info;
-    let destroyed = false;
-    log(`${localName}: Connecting call sender`);
-    const createMethodProxy = (methodName) => {
-      return (...args) => {
-        log(`${localName}: Sending ${methodName}() call`);
-        let iframeRemoved;
-        try {
-          if (remote.closed) {
-            iframeRemoved = true;
+      var bindAll = (inst, methods) => {
+        for (const methodName of methods) {
+          const method = inst[methodName];
+          if (typeof method === "function") {
+            inst[methodName] = method.bind(inst);
           }
-        } catch (e) {
-          iframeRemoved = true;
         }
-        if (iframeRemoved) {
-          destroyConnection();
+      };
+      var ObjectSimulator = class {
+        constructor(subject, cleanupNotifier) {
+          this.fnCounter = 0;
+          this.receiverTicketCache = /* @__PURE__ */ new WeakMap();
+          this.senderCache = /* @__PURE__ */ new WeakMap();
+          this.cleanupNotifier = cleanupNotifier;
+          this.subject = subject;
+          bindAll(this, ["makeSender", "makeReceiver", "simulate", "materialize"]);
         }
-        if (destroyed) {
-          const error = new Error(`Unable to send ${methodName}() call due to destroyed connection`);
-          error.code = ErrorCode.ConnectionDestroyed;
-          throw error;
+        static create(emitter, Cleanup) {
+          let simulator;
+          const simulatorInterface = {
+            simulate: (x) => simulator.simulate(x),
+            materialize: (x) => simulator.materialize(x)
+          };
+          const subject = new RemoteSubject(emitter, simulatorInterface);
+          const cleanupNotifier = new Cleanup((fnId) => {
+            return subject.notifyCleanup({ fnId });
+          });
+          simulator = new ObjectSimulator(subject, cleanupNotifier);
+          return simulator;
         }
-        return new Promise((resolve, reject) => {
-          const id2 = generateId_default();
-          const handleMessageEvent = (event) => {
-            if (event.source !== remote || event.data.penpal !== MessageType.Reply || event.data.id !== id2) {
-              return;
-            }
-            if (originForReceiving !== "*" && event.origin !== originForReceiving) {
-              log(`${localName} received message from origin ${event.origin} which did not match expected origin ${originForReceiving}`);
-              return;
+        makeReceiver(fn, parent) {
+          if (typeof fn !== "function") {
+            return NOT_TRANSFORMED;
+          }
+          let fnTicket = this.receiverTicketCache.get(fn);
+          if (!fnTicket) {
+            fnTicket = {
+              fnId: `${fn.name || "<anonymous>"}_${++this.fnCounter}`
+            };
+            let boundFunction = fn;
+            if (parent) {
+              boundFunction = fn.bind(parent);
             }
-            const replyMessage = event.data;
-            log(`${localName}: Received ${methodName}() reply`);
-            local.removeEventListener(NativeEventType.Message, handleMessageEvent);
-            let returnValue = replyMessage.returnValue;
-            if (replyMessage.returnValueIsError) {
-              returnValue = deserializeError(returnValue);
+            const cleanup = receiveCalls(
+              boundFunction,
+              fnTicket,
+              new WeakRef(this.subject)
+            );
+            this.subject.onOutOfScope(fnTicket, cleanup);
+            this.receiverTicketCache.set(boundFunction, fnTicket);
+          }
+          return wrap(fnTicket);
+        }
+        makeSender(message) {
+          if (!isDefMessage(message)) {
+            return NOT_TRANSFORMED;
+          }
+          const ticket = unwrap(message);
+          if (!this.senderCache.has(ticket)) {
+            const sender = makeCallSender(ticket, new WeakRef(this.subject));
+            this.cleanupNotifier.register(sender, ticket.fnId, sender);
+            this.senderCache.set(ticket, sender);
+            return sender;
+          } else {
+            return this.senderCache.get(ticket);
+          }
+        }
+        materialize(simulated) {
+          return transformRecursive(
+            this.makeSender,
+            simulated
+          );
+        }
+        simulate(localObject) {
+          return transformRecursive(
+            this.makeReceiver,
+            localObject
+          );
+        }
+      };
+      function timeoutPromise2(description, promise, ms, onReject) {
+        return new Promise((resolve, reject) => {
+          const cleanupAndReject = async (e) => {
+            try {
+              await onReject(e);
+            } finally {
+              reject(e);
             }
-            (replyMessage.resolution === Resolution.Fulfilled ? resolve : reject)(returnValue);
-          };
-          local.addEventListener(NativeEventType.Message, handleMessageEvent);
-          const callMessage = {
-            penpal: MessageType.Call,
-            id: id2,
-            methodName,
-            args
           };
-          remote.postMessage(callMessage, originForSending);
+          const timeout = setTimeout(() => {
+            cleanupAndReject(new Error(`${description} timed out after ${ms}ms`));
+          }, ms);
+          promise.then((result) => {
+            clearTimeout(timeout);
+            resolve(result);
+          }).catch((e) => {
+            clearTimeout(timeout);
+            cleanupAndReject(e);
+          });
         });
-      };
-    };
-    const flattenedMethods = methodKeyPaths.reduce((api, name) => {
-      api[name] = createMethodProxy(name);
-      return api;
-    }, {});
-    Object.assign(callSender, deserializeMethods(flattenedMethods));
-    return () => {
-      destroyed = true;
-    };
-  };
-
-  // ../../node_modules/penpal/lib/startConnectionTimeout.js
-  var startConnectionTimeout_default = (timeout, callback) => {
-    let timeoutId;
-    if (timeout !== void 0) {
-      timeoutId = window.setTimeout(() => {
-        const error = new Error(`Connection timed out after ${timeout}ms`);
-        error.code = ErrorCode.ConnectionTimeout;
-        callback(error);
-      }, timeout);
-    }
-    return () => {
-      clearTimeout(timeoutId);
-    };
-  };
-
-  // ../../node_modules/penpal/lib/child/handleSynAckMessageFactory.js
-  var handleSynAckMessageFactory_default = (parentOrigin, serializedMethods, destructor, log) => {
-    const { destroy, onDestroy } = destructor;
-    return (event) => {
-      let originQualifies = parentOrigin instanceof RegExp ? parentOrigin.test(event.origin) : parentOrigin === "*" || parentOrigin === event.origin;
-      if (!originQualifies) {
-        log(`Child: Handshake - Received SYN-ACK from origin ${event.origin} which did not match expected origin ${parentOrigin}`);
-        return;
       }
-      log("Child: Handshake - Received SYN-ACK, responding with ACK");
-      const originForSending = event.origin === "null" ? "*" : event.origin;
-      const ackMessage = {
-        penpal: MessageType.Ack,
-        methodNames: Object.keys(serializedMethods)
-      };
-      window.parent.postMessage(ackMessage, originForSending);
-      const info = {
-        localName: "Child",
-        local: window,
-        remote: window.parent,
-        originForSending,
-        originForReceiving: event.origin
+      var INIT_TICKET = {
+        fnId: INIT_CALLBACK
       };
-      const destroyCallReceiver = connectCallReceiver_default(info, serializedMethods, log);
-      onDestroy(destroyCallReceiver);
-      const callSender = {};
-      const destroyCallSender = connectCallSender_default(callSender, info, event.data.methodNames, destroy, log);
-      onDestroy(destroyCallSender);
-      return callSender;
-    };
-  };
-
-  // ../../node_modules/penpal/lib/child/connectToParent.js
-  var areGlobalsAccessible = () => {
-    try {
-      clearTimeout();
-    } catch (e) {
-      return false;
-    }
-    return true;
-  };
-  var connectToParent_default = (options = {}) => {
-    const { parentOrigin = "*", methods = {}, timeout, debug = false } = options;
-    const log = createLogger_default(debug);
-    const destructor = createDestructor_default("Child", log);
-    const { destroy, onDestroy } = destructor;
-    const serializedMethods = serializeMethods(methods);
-    const handleSynAckMessage = handleSynAckMessageFactory_default(parentOrigin, serializedMethods, destructor, log);
-    const sendSynMessage = () => {
-      log("Child: Handshake - Sending SYN");
-      const synMessage = { penpal: MessageType.Syn };
-      const parentOriginForSyn = parentOrigin instanceof RegExp ? "*" : parentOrigin;
-      window.parent.postMessage(synMessage, parentOriginForSyn);
-    };
-    const promise = new Promise((resolve, reject) => {
-      const stopConnectionTimeout = startConnectionTimeout_default(timeout, destroy);
-      const handleMessage = (event) => {
-        if (!areGlobalsAccessible()) {
-          return;
-        }
-        if (event.source !== parent || !event.data) {
-          return;
-        }
-        if (event.data.penpal === MessageType.SynAck) {
-          const callSender = handleSynAckMessage(event);
-          if (callSender) {
-            window.removeEventListener(NativeEventType.Message, handleMessage);
-            stopConnectionTimeout();
-            resolve(callSender);
+      var import_eventemitter3 = __toESM2(require_eventemitter3());
+      var TunnelMessenger = class {
+        constructor(opts) {
+          this.versionWarnings = /* @__PURE__ */ new Set();
+          this.myOrigin = opts.myOrigin;
+          this.remoteOrigin = opts.targetOrigin === "*" ? "remote document" : opts.targetOrigin;
+          this.logger = opts.logger;
+        }
+        resetWarnings() {
+          this.versionWarnings.clear();
+        }
+        makeAccepted(id) {
+          return wrap({
+            accepts: id,
+            version: VERSION
+          });
+        }
+        makeOffered(id) {
+          return wrap({
+            offers: id,
+            version: VERSION
+          });
+        }
+        isHandshakeAccepting(message, id) {
+          return this.isHandshake(message) && unwrap(message).accepts === id;
+        }
+        isHandshakeOffer(message) {
+          return this.isHandshake(message) && typeof unwrap(message).offers === "string";
+        }
+        isHandshake(message) {
+          if (!isWrapped(message)) {
+            this.logMalformed(message);
+            return false;
+          }
+          const tunnelData = unwrap(
+            message
+          );
+          if (!isPlainObject(tunnelData) || typeof tunnelData.version !== "string" || !(Reflect.has(tunnelData, "accepts") || Reflect.has(tunnelData, "offers"))) {
+            this.logMalformed(message);
+            return false;
+          }
+          const { version } = tunnelData;
+          if (version !== VERSION && !this.versionWarnings.has(version)) {
+            this.versionWarnings.add(version);
+            this.logger.warn(
+              `SDK version mismatch. ${this.myOrigin} is using v${VERSION}, but received message from ${this.remoteOrigin} using SDK v${version}. Extensions may be broken or unresponsive.`
+            );
           }
+          return true;
+        }
+        logMalformed(message) {
+          let inspectedMessage;
+          try {
+            inspectedMessage = JSON.stringify(message, null, 2);
+          } catch (_) {
+            try {
+              inspectedMessage = message.toString();
+            } catch (e) {
+              inspectedMessage = Object.prototype.toString.call(message);
+            }
+          }
+          this.logger.error(
+            `Malformed tunnel message sent from SDK at ${this.remoteOrigin} to ${this.myOrigin}:
+${inspectedMessage}
+Message must be an object with "${NS_ROOT}" property, which must be an object with a "version" string and an either an "accepts" or "offers" property containing an ID string.`
+          );
         }
       };
-      window.addEventListener(NativeEventType.Message, handleMessage);
-      sendSynMessage();
-      onDestroy((error) => {
-        window.removeEventListener(NativeEventType.Message, handleMessage);
-        if (error) {
-          reject(error);
+      var RETRY_MS = 100;
+      var STATUSCHECK_MS = 5e3;
+      var KEY_BASE = 36;
+      var KEY_LENGTH = 8;
+      var KEY_EXP = KEY_BASE ** KEY_LENGTH;
+      var makeKey = () => Math.round(Math.random() * KEY_EXP).toString(KEY_BASE);
+      var badTimeout = "\n - timeout value must be a number of milliseconds";
+      var badTargetOrigin = "\n - targetOrigin must be a valid URL origin or '*' for any origin";
+      function isFromOrigin(event, source, targetOrigin) {
+        try {
+          return source === event.source && (targetOrigin === "*" || targetOrigin === new URL(event.origin).origin);
+        } catch (_) {
+          return false;
         }
-      });
-    });
-    return {
-      promise,
-      destroy() {
-        destroy();
       }
-    };
-  };
+      var { emit: emitOn } = import_eventemitter3.default.prototype;
+      var Tunnel = class extends import_eventemitter3.default {
+        constructor(config) {
+          super();
+          this.emitLocal = (type, payload) => {
+            return emitOn.call(this, type, payload);
+          };
+          this._emitFromMessage = ({ data: { type, payload } }) => {
+            this.emitLocal(type, payload);
+          };
+          this.config = config;
+        }
+        static toIframe(target, options) {
+          if (!isIframe(target)) {
+            throw new Error(
+              `Provided tunnel target is not an iframe! ${Object.prototype.toString.call(
+                target
+              )}`
+            );
+          }
+          const source = target.contentWindow;
+          const config = Tunnel._normalizeConfig(options);
+          const tunnel = new Tunnel(config);
+          const messenger = new TunnelMessenger({
+            myOrigin: window.location.origin,
+            targetOrigin: options.targetOrigin,
+            logger: options.logger || console
+          });
+          let frameStatusCheck;
+          let timeout;
+          const offerListener = (event) => {
+            if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeOffer(event.data)) {
+              const accepted = messenger.makeAccepted(unwrap(event.data).offers);
+              const channel = new MessageChannel();
+              source.postMessage(accepted, config.targetOrigin, [channel.port1]);
+              tunnel.connect(channel.port2);
+            }
+          };
+          const cleanup = () => {
+            clearTimeout(timeout);
+            clearInterval(frameStatusCheck);
+            window.removeEventListener("message", offerListener);
+          };
+          timeout = window.setTimeout(() => {
+            tunnel.emitLocal(
+              "error",
+              new Error(
+                `Timed out awaiting initial message from iframe after ${config.timeout}ms`
+              )
+            );
+            tunnel.destroy();
+          }, config.timeout);
+          tunnel.on("destroyed", cleanup);
+          tunnel.on("connected", () => clearTimeout(timeout));
+          frameStatusCheck = window.setInterval(() => {
+            if (!target.isConnected) {
+              tunnel.destroy();
+            }
+          }, STATUSCHECK_MS);
+          window.addEventListener("message", offerListener);
+          return tunnel;
+        }
+        static toParent(source, opts) {
+          let retrying;
+          let timeout;
+          const key = makeKey();
+          const config = Tunnel._normalizeConfig(opts);
+          const tunnel = new Tunnel(config);
+          const messenger = new TunnelMessenger({
+            myOrigin: window.location.origin,
+            targetOrigin: config.targetOrigin,
+            logger: config.logger
+          });
+          const acceptListener = (event) => {
+            if (isFromOrigin(event, source, config.targetOrigin) && messenger.isHandshakeAccepting(event.data, key)) {
+              cleanup();
+              if (!event.ports || !event.ports.length) {
+                const portError = new Error(
+                  "Received handshake accept message, but it did not include a MessagePort to establish tunnel"
+                );
+                tunnel.emitLocal("error", portError);
+                return;
+              }
+              tunnel.connect(event.ports[0]);
+            }
+          };
+          const cleanup = () => {
+            clearInterval(retrying);
+            clearTimeout(timeout);
+            window.removeEventListener("message", acceptListener);
+          };
+          timeout = window.setTimeout(() => {
+            tunnel.emitLocal(
+              "error",
+              new Error(
+                `Timed out waiting for initial response from parent after ${config.timeout}ms`
+              )
+            );
+            tunnel.destroy();
+          }, config.timeout);
+          window.addEventListener("message", acceptListener);
+          tunnel.on("destroyed", cleanup);
+          tunnel.on("connected", cleanup);
+          const sendOffer = () => source.postMessage(messenger.makeOffered(key), config.targetOrigin);
+          retrying = window.setInterval(sendOffer, RETRY_MS);
+          sendOffer();
+          return tunnel;
+        }
+        connect(remote) {
+          if (this._messagePort) {
+            this._messagePort.removeEventListener("message", this._emitFromMessage);
+            this._messagePort.close();
+          }
+          this._messagePort = remote;
+          remote.addEventListener("message", this._emitFromMessage);
+          this.emit("connected");
+          this._messagePort.start();
+        }
+        destroy() {
+          if (this._messagePort) {
+            this._messagePort.close();
+            this._messagePort = null;
+          }
+          this.emitLocal("destroyed");
+          this.emit("destroyed");
+        }
+        emit(type, payload) {
+          if (!this._messagePort) {
+            return false;
+          }
+          this._messagePort.postMessage({ type, payload });
+          return true;
+        }
+        static _normalizeConfig(options = {}) {
+          let errorMessage = "";
+          const config = {
+            timeout: 4e3,
+            logger: console,
+            ...options
+          };
+          const timeoutMs = Number(config.timeout);
+          if (!Number.isSafeInteger(timeoutMs)) {
+            errorMessage += badTimeout;
+          }
+          if (config.targetOrigin !== "*") {
+            try {
+              new URL(config.targetOrigin);
+            } catch (e) {
+              errorMessage += badTargetOrigin;
+            }
+          }
+          if (errorMessage) {
+            throw new Error(`Invalid tunnel configuration: ${errorMessage}`);
+          }
+          return config;
+        }
+      };
+      var INIT_MESSAGE = wrap(INIT_TICKET);
+      async function setupApiExchange(tunnel, apiToSend) {
+        let done = false;
+        let remoteApi;
+        const xrObject = {
+          tunnel,
+          getRemoteApi() {
+            return remoteApi;
+          }
+        };
+        return timeoutPromise2(
+          "Initial API exchange",
+          new Promise((resolve, reject) => {
+            const simulator = ObjectSimulator.create(tunnel, FinalizationRegistry);
+            const sendApi = simulator.makeSender(INIT_MESSAGE);
+            const apiCallback = (api) => {
+              remoteApi = api;
+              if (!done) {
+                done = true;
+                resolve(xrObject);
+              }
+            };
+            tunnel.on("api", apiCallback);
+            const unsubscribe = receiveCalls(
+              (api) => tunnel.emitLocal("api", api),
+              INIT_TICKET,
+              new WeakRef(simulator.subject)
+            );
+            const destroy = (e) => {
+              unsubscribe();
+              if (!done) {
+                done = true;
+                reject(e);
+              }
+            };
+            tunnel.on("destroyed", destroy);
+            tunnel.on(
+              "connected",
+              () => sendApi(apiToSend).catch(destroy)
+            );
+          }),
+          tunnel.config.timeout,
+          () => tunnel.destroy()
+        );
+      }
+      async function connectParentWindow2(tunnelOptions, apiToSend) {
+        const tunnel = Tunnel.toParent(window.parent, tunnelOptions);
+        return setupApiExchange(tunnel, apiToSend);
+      }
+      async function connectIframe(frame, tunnelOptions, apiToSend) {
+        const tunnel = Tunnel.toIframe(frame, tunnelOptions);
+        return setupApiExchange(tunnel, apiToSend);
+      }
+      function wait(ms) {
+        return new Promise((resolve) => {
+          setTimeout(resolve, ms);
+        });
+      }
+      exports.Emitter = Emitter2;
+      exports.Tunnel = Tunnel;
+      exports._customConsole = _customConsole;
+      exports.connectIframe = connectIframe;
+      exports.connectParentWindow = connectParentWindow2;
+      exports.debugEmitter = debugEmitter2;
+      exports.makeNamespaceProxy = makeNamespaceProxy2;
+      exports.quietConsole = quietConsole2;
+      exports.timeoutPromise = timeoutPromise2;
+      exports.wait = wait;
+    }
+  });
+
+  // src/index.ts
+  var src_exports = {};
+  __export(src_exports, {
+    GuestServer: () => GuestServer,
+    GuestUI: () => GuestUI,
+    PrimaryGuest: () => GuestServer,
+    UIGuest: () => GuestUI,
+    attach: () => attach,
+    createGuest: () => createGuest,
+    register: () => register
+  });
 
   // src/guest.ts
   var import_uix_core2 = __toESM(require_dist());
@@ -681,14 +1205,18 @@ var AdobeUIXGuest = (() => {
   var Guest2 = class extends import_uix_core2.Emitter {
     constructor(config) {
       super(config.id);
-      this.debugLogger = import_uix_core2.quietConsole;
+      this.logger = import_uix_core2.quietConsole;
       this.host = (0, import_uix_core2.makeNamespaceProxy)(
         async (address) => {
           await this.hostConnectionPromise;
           try {
             const result = await (0, import_uix_core2.timeoutPromise)(
+              `Calling host method ${address.path.join(".")}${address.name}(...)`,
+              this.hostConnection.getRemoteApi().invokeHostMethod(address),
               1e4,
-              this.hostConnection.invokeHostMethod(address)
+              (e) => {
+                this.logger.error(e);
+              }
             );
             return result;
           } catch (e) {
@@ -696,7 +1224,7 @@ var AdobeUIXGuest = (() => {
             const methodError = new Error(
               `Host method call host.${address.path.join(".")}() failed: ${error.message}`
             );
-            this.debugLogger.error(methodError);
+            this.logger.error(methodError);
             throw methodError;
           }
         }
@@ -706,7 +1234,7 @@ var AdobeUIXGuest = (() => {
         this.timeout = config.timeout;
       }
       if (config.debug) {
-        this.debugLogger = debugGuest(this);
+        this.logger = debugGuest(this);
       }
       this.addEventListener("contextchange", (event) => {
         this.sharedContext = new SharedContext(event.detail.context);
@@ -715,7 +1243,7 @@ var AdobeUIXGuest = (() => {
     getLocalMethods() {
       return {
         emit: (...args) => {
-          this.debugLogger.log(`Event "${args[0]}" emitted from host`);
+          this.logger.log(`Event "${args[0]}" emitted from host`);
           this.emit(...args);
         }
       };
@@ -726,20 +1254,28 @@ var AdobeUIXGuest = (() => {
     async _connect() {
       this.emit("beforeconnect", { guest: this });
       try {
-        const connection = connectToParent_default({
-          timeout: this.timeout,
-          methods: this.getLocalMethods()
-        });
-        this.hostConnectionPromise = connection.promise;
+        const hostConnectionPromise = (0, import_uix_core2.connectParentWindow)(
+          {
+            targetOrigin: "*",
+            timeout: this.timeout,
+            logger: this.logger
+          },
+          this.getLocalMethods()
+        );
+        this.hostConnectionPromise = hostConnectionPromise;
         this.hostConnection = await this.hostConnectionPromise;
+      } catch (e) {
+        this.emit("error", { guest: this, error: e });
+        this.logger.error("Connection failed!", e);
+        return;
+      }
+      try {
         this.sharedContext = new SharedContext(
-          await this.hostConnection.getSharedContext()
+          await this.hostConnection.getRemoteApi().getSharedContext()
         );
-        this.debugLogger.log("retrieved sharedContext", this.sharedContext);
-        this.emit("connected", { guest: this, connection });
       } catch (e) {
         this.emit("error", { guest: this, error: e });
-        this.debugLogger.error("Connection failed!", e);
+        this.logger.error("getSharedContext failed!", e);
       }
     }
   };