@openfin/core 37.80.38 → 37.81.17

package/out/mock.js

@@ -299,13 +299,13 @@ async function promiseMapSerial(arr, func) {
 }
 promises.promiseMapSerial = promiseMapSerial;
 
-var __classPrivateFieldSet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$f = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -392,8 +392,8 @@ class EmitterBase extends Base {
         this.emit = (eventType, payload, ...args) => {
             return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
         };
-        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$f(this, _EmitterBase_emitterAccessor, "f"));
-        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$f(this, _EmitterBase_emitterAccessor, "f"));
+        this.hasEmitter = () => this.wire.eventAggregator.has(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
+        this.getOrCreateEmitter = () => this.wire.eventAggregator.getOrCreate(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
         this.listeners = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(type) : [];
         this.listenerCount = (type) => this.hasEmitter() ? this.getOrCreateEmitter().listenerCount(type) : 0;
         this.registerEventListener = async (eventType, options = {}, applySubscription, undoSubscription) => {
@@ -431,7 +431,7 @@ class EmitterBase extends Base {
             // This will only be reached if unsubscribe from event that does not exist but do not want to error here
             return Promise.resolve();
         };
-        __classPrivateFieldSet$d(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
+        __classPrivateFieldSet$c(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
         this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
     }
     /**
@@ -549,7 +549,7 @@ class EmitterBase extends Base {
     }
     deleteEmitterIfNothingRegistered(emitter) {
         if (emitter.eventNames().length === 0) {
-            this.wire.eventAggregator.delete(__classPrivateFieldGet$f(this, _EmitterBase_emitterAccessor, "f"));
+            this.wire.eventAggregator.delete(__classPrivateFieldGet$e(this, _EmitterBase_emitterAccessor, "f"));
         }
     }
 }
@@ -1149,13 +1149,13 @@ const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async
 };
 channelApiRelay.createRelayedDispatch = createRelayedDispatch;
 
-var __classPrivateFieldSet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -1209,7 +1209,7 @@ class LayoutNode {
          * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);
          * ```
          */
-        this.isRoot = () => __classPrivateFieldGet$e(this, _LayoutNode_client, "f").isRoot(this.entityId);
+        this.isRoot = () => __classPrivateFieldGet$d(this, _LayoutNode_client, "f").isRoot(this.entityId);
         /**
          * Checks if the TabStack or ColumnOrRow exists
          *
@@ -1229,7 +1229,7 @@ class LayoutNode {
          * console.log(`The entity exists: ${exists}`);
          * ```
          */
-        this.exists = () => __classPrivateFieldGet$e(this, _LayoutNode_client, "f").exists(this.entityId);
+        this.exists = () => __classPrivateFieldGet$d(this, _LayoutNode_client, "f").exists(this.entityId);
         /**
          * Retrieves the parent of the TabStack or ColumnOrRow
          *
@@ -1250,11 +1250,11 @@ class LayoutNode {
          * ```
          */
         this.getParent = async () => {
-            const parent = await __classPrivateFieldGet$e(this, _LayoutNode_client, "f").getParent(this.entityId);
+            const parent = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").getParent(this.entityId);
             if (!parent) {
                 return undefined;
             }
-            return LayoutNode.getEntity(parent, __classPrivateFieldGet$e(this, _LayoutNode_client, "f"));
+            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
         };
         /**
          * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.
@@ -1305,8 +1305,8 @@ class LayoutNode {
          * @experimental
          */
         this.createAdjacentStack = async (views, options) => {
-            const entityId = await __classPrivateFieldGet$e(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
-            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$e(this, _LayoutNode_client, "f"));
+            const entityId = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
+            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
         };
         /**
          * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.
@@ -1334,16 +1334,16 @@ class LayoutNode {
          * @experimental
          */
         this.getAdjacentStacks = async (edge) => {
-            const adjacentStacks = await __classPrivateFieldGet$e(this, _LayoutNode_client, "f").getAdjacentStacks({
+            const adjacentStacks = await __classPrivateFieldGet$d(this, _LayoutNode_client, "f").getAdjacentStacks({
                 targetId: this.entityId,
                 edge
             });
             return adjacentStacks.map((stack) => LayoutNode.getEntity({
                 type: 'stack',
                 entityId: stack.entityId
-            }, __classPrivateFieldGet$e(this, _LayoutNode_client, "f")));
+            }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f")));
         };
-        __classPrivateFieldSet$c(this, _LayoutNode_client, client, "f");
+        __classPrivateFieldSet$b(this, _LayoutNode_client, client, "f");
         this.entityId = entityId;
     }
 }
@@ -1416,7 +1416,7 @@ class TabStack extends LayoutNode {
          * ```
          * @experimental
          */
-        this.getViews = () => __classPrivateFieldGet$e(this, _TabStack_client, "f").getStackViews(this.entityId);
+        this.getViews = () => __classPrivateFieldGet$d(this, _TabStack_client, "f").getStackViews(this.entityId);
         /**
          * Adds or creates a view in this {@link TabStack}.
          *
@@ -1446,7 +1446,7 @@ class TabStack extends LayoutNode {
          * ```
          * @experimental
          */
-        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$e(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
+        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$d(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
         /**
          * Removes a view from this {@link TabStack}.
          *
@@ -1476,7 +1476,7 @@ class TabStack extends LayoutNode {
          * ```
          */
         this.removeView = async (view) => {
-            await __classPrivateFieldGet$e(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
+            await __classPrivateFieldGet$d(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
         };
         /**
          * Sets the active view of the {@link TabStack} without focusing it.
@@ -1500,9 +1500,9 @@ class TabStack extends LayoutNode {
          * @experimental
          */
         this.setActiveView = async (view) => {
-            await __classPrivateFieldGet$e(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
+            await __classPrivateFieldGet$d(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
         };
-        __classPrivateFieldSet$c(this, _TabStack_client, client, "f");
+        __classPrivateFieldSet$b(this, _TabStack_client, client, "f");
     }
 }
 layoutEntities.TabStack = TabStack;
@@ -1541,10 +1541,10 @@ class ColumnOrRow extends LayoutNode {
          * ```
          */
         this.getContent = async () => {
-            const contentItemEntities = await __classPrivateFieldGet$e(this, _ColumnOrRow_client, "f").getContent(this.entityId);
-            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$e(this, _ColumnOrRow_client, "f")));
+            const contentItemEntities = await __classPrivateFieldGet$d(this, _ColumnOrRow_client, "f").getContent(this.entityId);
+            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, "f")));
         };
-        __classPrivateFieldSet$c(this, _ColumnOrRow_client, client, "f");
+        __classPrivateFieldSet$b(this, _ColumnOrRow_client, client, "f");
         this.type = type;
     }
 }
@@ -1563,8 +1563,8 @@ var main = {};
 
 Object.defineProperty(main, "__esModule", { value: true });
 main.WebContents = void 0;
-const base_1$k = base;
-class WebContents extends base_1$k.EmitterBase {
+const base_1$j = base;
+class WebContents extends base_1$j.EmitterBase {
     /**
      * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
      * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
@@ -4365,6 +4365,37 @@ function requireApplication () {
 	return application;
 }
 
+var promisifySubscription$1 = {};
+
+Object.defineProperty(promisifySubscription$1, "__esModule", { value: true });
+promisifySubscription$1.promisifySubscription = void 0;
+const promisifySubscription = async (emitter, eventName, predicate = () => true, timeout) => {
+    let resolve;
+    let reject;
+    let timer;
+    const valuePromise = new Promise((y, n) => {
+        resolve = y;
+        reject = n;
+    });
+    const listener = (e) => {
+        if (predicate(e)) {
+            clearTimeout(timer);
+            resolve(e);
+        }
+    };
+    await emitter.on(eventName, listener);
+    if (timeout) {
+        timer = setTimeout(() => reject(new Error('event timed out')), timeout);
+    }
+    valuePromise.finally(() => {
+        emitter.removeListener(eventName, listener).catch(() => null);
+    });
+    return {
+        getValue: () => valuePromise
+    };
+};
+promisifySubscription$1.promisifySubscription = promisifySubscription;
+
 var hasRequiredInstance;
 
 function requireInstance () {
@@ -4380,6 +4411,7 @@ function requireInstance () {
 	const main_1 = main;
 	const view_1 = requireView();
 	const warnings_1 = warnings;
+	const promisifySubscription_1 = promisifySubscription$1;
 	/**
 	 * A basic window that wraps a native HTML window. Provides more fine-grained
 	 * control over the window state such as the ability to minimize, maximize, restore, etc.
@@ -4395,79 +4427,60 @@ function requireInstance () {
 	    constructor(wire, identity) {
 	        super(wire, identity, 'window');
 	    }
-	    /**
-	     * create a new window
-	     * @internal
-	     */
-	    createWindow(options) {
+	    async createWindow(options) {
 	        this.wire.sendAction('window-create-window', this.identity).catch((e) => {
 	            // we do not want to expose this error, just continue if this analytics-only call fails
 	        });
-	        return new Promise((resolve, reject) => {
-	            const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';
-	            // need to call pageResponse, otherwise when a child window is created, page is not loaded
-	            const pageResponse = new Promise((resolve) => {
-	                // TODO: fix typing (internal)
-	                // @ts-expect-error
-	                this.on(CONSTRUCTOR_CB_TOPIC, function fireConstructor(response) {
-	                    let cbPayload;
-	                    const { success } = response;
-	                    const responseData = response.data;
-	                    const { message } = responseData;
-	                    if (success) {
-	                        cbPayload = {
-	                            httpResponseCode: responseData.httpResponseCode,
-	                            apiInjected: responseData.apiInjected
-	                        };
-	                    }
-	                    else {
-	                        cbPayload = {
-	                            message: responseData.message,
-	                            networkErrorCode: responseData.networkErrorCode,
-	                            stack: responseData.stack
-	                        };
-	                    }
-	                    this.removeListener(CONSTRUCTOR_CB_TOPIC, fireConstructor);
-	                    resolve({
-	                        message,
-	                        cbPayload,
-	                        success
-	                    });
-	                });
-	            });
-	            // set defaults:
-	            if (options.waitForPageLoad === undefined) {
-	                options.waitForPageLoad = false;
-	            }
-	            if (options.autoShow === undefined) {
-	                options.autoShow = true;
-	            }
-	            (0, warnings_1.handleDeprecatedWarnings)(options);
-	            const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });
-	            Promise.all([pageResponse, windowCreation])
-	                .then((resolvedArr) => {
-	                const pageResolve = resolvedArr[0];
-	                if (pageResolve.success) {
-	                    resolve(this);
-	                }
-	                else {
-	                    reject(pageResolve);
-	                }
-	                try {
-	                    // this is to enforce a 5.0 contract that the child's main function
-	                    // will not fire before the parent's success callback on creation.
-	                    // if the child window is not accessible (CORS) this contract does
-	                    // not hold.
-	                    const webWindow = this.getWebWindow();
-	                    webWindow.fin.__internal_.openerSuccessCBCalled();
-	                }
-	                catch (e) {
-	                    // common for main windows, we do not want to expose this error. here just to have a debug target.
-	                    // console.error(e);
-	                }
-	            })
-	                .catch(reject);
-	        });
+	        const CONSTRUCTOR_CB_TOPIC = 'fire-constructor-callback';
+	        const responseSubscription = await (0, promisifySubscription_1.promisifySubscription)(this, CONSTRUCTOR_CB_TOPIC);
+	        // set defaults:
+	        if (options.waitForPageLoad === undefined) {
+	            options.waitForPageLoad = false;
+	        }
+	        if (options.autoShow === undefined) {
+	            options.autoShow = true;
+	        }
+	        (0, warnings_1.handleDeprecatedWarnings)(options);
+	        const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });
+	        const [response] = await Promise.all([responseSubscription.getValue(), windowCreation]);
+	        let cbPayload;
+	        const { success } = response;
+	        const responseData = response.data;
+	        const { message } = responseData;
+	        if (success) {
+	            cbPayload = {
+	                httpResponseCode: responseData.httpResponseCode,
+	                apiInjected: responseData.apiInjected
+	            };
+	        }
+	        else {
+	            cbPayload = {
+	                message: responseData.message,
+	                networkErrorCode: responseData.networkErrorCode,
+	                stack: responseData.stack
+	            };
+	        }
+	        const pageResolve = {
+	            message,
+	            cbPayload,
+	            success
+	        };
+	        try {
+	            // this is to enforce a 5.0 contract that the child's main function
+	            // will not fire before the parent's success callback on creation.
+	            // if the child window is not accessible (CORS) this contract does
+	            // not hold.
+	            const webWindow = this.getWebWindow();
+	            webWindow.fin.__internal_.openerSuccessCBCalled();
+	        }
+	        catch (e) {
+	            // common for main windows, we do not want to expose this error. here just to have a debug target.
+	            // console.error(e);
+	        }
+	        if (pageResolve.success) {
+	            return this;
+	        }
+	        return Promise.reject(pageResolve);
 	    }
 	    /**
 	     * Retrieves an array of frame info objects representing the main frame and any
@@ -5846,7 +5859,7 @@ function requireWindow () {
  */
 Object.defineProperty(system, "__esModule", { value: true });
 system.System = void 0;
-const base_1$j = base;
+const base_1$i = base;
 const transport_errors_1$1 = transportErrors;
 const window_1 = requireWindow();
 const events_1$6 = require$$0;
@@ -5856,7 +5869,7 @@ const events_1$6 = require$$0;
  * clearing the cache and exiting the runtime as well as listen to {@link OpenFin.SystemEvents system events}.
  *
  */
-class System extends base_1$j.EmitterBase {
+class System extends base_1$i.EmitterBase {
     /**
      * @internal
      */
@@ -7762,9 +7775,10 @@ class ProtectedItems {
     /**
      * @internal
      */
-    constructor(providerIdentity, wire) {
+    // eslint-disable-next-line no-useless-constructor
+    constructor(providerIdentity, close) {
         this.providerIdentity = providerIdentity;
-        this.wire = wire;
+        this.close = close;
     }
 }
 channel.ProtectedItems = ProtectedItems;
@@ -8086,12 +8100,12 @@ class ChannelBase {
 }
 channel.ChannelBase = ChannelBase;
 
-var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -8133,7 +8147,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
     static closeChannelByEndpointId(id) {
         const channel = channelClientsByEndpointId.get(id);
         if (channel) {
-            __classPrivateFieldGet$d(channel, _ChannelClient_close, "f").call(channel);
+            __classPrivateFieldGet$c(channel, _ChannelClient_close, "f").call(channel);
         }
     }
     /**
@@ -8144,14 +8158,14 @@ class ChannelClient extends channel_1$1.ChannelBase {
         for (const channelClient of channelClientsByEndpointId.values()) {
             if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
                 channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet$d(channelClient, _ChannelClient_close, "f").call(channelClient);
+                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, "f").call(channelClient);
             }
         }
     }
     /**
      * @internal
      */
-    constructor(routingInfo, wire, strategy) {
+    constructor(routingInfo, close, strategy) {
         super();
         _ChannelClient_protectedObj.set(this, void 0);
         _ChannelClient_strategy.set(this, void 0);
@@ -8159,12 +8173,12 @@ class ChannelClient extends channel_1$1.ChannelBase {
         this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
         _ChannelClient_close.set(this, () => {
             channelClientsByEndpointId.delete(this.endpointId);
-            __classPrivateFieldGet$d(this, _ChannelClient_strategy, "f").close();
+            __classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").close();
         });
-        __classPrivateFieldSet$b(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, wire), "f");
+        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
         this.disconnectListener = () => undefined;
         this.endpointId = routingInfo.endpointId;
-        __classPrivateFieldSet$b(this, _ChannelClient_strategy, strategy, "f");
+        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, "f");
         channelClientsByEndpointId.set(this.endpointId, this);
         strategy.receive(this.processAction);
     }
@@ -8172,7 +8186,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * a read-only provider identity
      */
     get providerIdentity() {
-        const protectedObj = __classPrivateFieldGet$d(this, _ChannelClient_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
         return protectedObj.providerIdentity;
     }
     /**
@@ -8201,8 +8215,8 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * ```
      */
     async dispatch(action, payload) {
-        if (__classPrivateFieldGet$d(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
-            return __classPrivateFieldGet$d(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
+        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
         }
         throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
     }
@@ -8252,16 +8266,23 @@ class ChannelClient extends channel_1$1.ChannelBase {
      */
     async disconnect() {
         await this.sendDisconnectAction();
-        __classPrivateFieldGet$d(this, _ChannelClient_close, "f").call(this);
+        __classPrivateFieldGet$c(this, _ChannelClient_close, "f").call(this);
     }
     async sendDisconnectAction() {
-        const protectedObj = __classPrivateFieldGet$d(this, _ChannelClient_protectedObj, "f");
-        const { channelName, uuid, name } = protectedObj.providerIdentity;
-        await protectedObj.wire.sendAction('disconnect-from-channel', {
+        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
+        await protectedObj.close();
+    }
+    /**
+     * @internal
+     * Writing this as a static to keep code together, but in environments with a wire, this will be DI'd into the protectedObject class as close.
+     */
+    static async wireClose(wire, providerIdentity, endpointId) {
+        const { channelName, uuid, name } = providerIdentity;
+        await wire.sendAction('disconnect-from-channel', {
             channelName,
             uuid,
             name,
-            endpointId: this.endpointId
+            endpointId
         });
     }
 }
@@ -8281,13 +8302,13 @@ exhaustive.exhaustiveCheck = exhaustiveCheck;
 
 var strategy$3 = {};
 
-var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -8312,7 +8333,7 @@ class ClassicStrategy {
         // connection problems occur
         _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
-            const to = __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
             }
@@ -8324,28 +8345,28 @@ class ClassicStrategy {
             }
             delete cleanId.isLocalEndpointId;
             // grab the promise before awaiting it to save in our pending messages map
-            const p = __classPrivateFieldGet$c(this, _ClassicStrategy_wire, "f")
+            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, "f")
                 .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
                 payload
             });
-            __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
+            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
             const raw = await p.catch((error) => {
                 throw new Error(error.message);
             }).finally(() => {
                 // clean up the pending promise
-                __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
+                __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
             });
             return raw.payload.data.result;
         };
         this.close = async () => {
             this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
-            [...__classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
-            __classPrivateFieldSet$a(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
+            [...__classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
+            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
-        __classPrivateFieldSet$a(this, _ClassicStrategy_wire, wire, "f");
+        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, "f");
     }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
@@ -8354,20 +8375,20 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
-        const id = __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
-        __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
-        const pendingSet = __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
         pendingSet?.forEach((p) => {
             const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;
             p.cancel(new Error(errorMsg));
         });
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
+        return __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
-        __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
+        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
         return (typeof payload?.endpointIdentity?.endpointId === 'string' ||
@@ -8398,12 +8419,12 @@ function errorToPOJO(error) {
 }
 errors.errorToPOJO = errorToPOJO;
 
-var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -8438,8 +8459,8 @@ class RTCEndpoint {
             if (this.rtc.rtcClient.connectionState !== 'connected') {
                 this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
                 this.close();
-                if (__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             }
         };
@@ -8487,9 +8508,9 @@ class RTCEndpoint {
                 data = new TextDecoder().decode(e.data);
             }
             const { messageId, action, payload } = JSON.parse(data);
-            if (__classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f")) {
+            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
                 try {
-                    const res = await __classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
+                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
                     this.rtc.channels.response.send(JSON.stringify({
                         messageId,
                         payload: res,
@@ -8523,25 +8544,25 @@ class RTCEndpoint {
             datachannel.onclose = (e) => {
                 [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));
                 this.close();
-                if (__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             };
         });
     }
     onDisconnect(listener) {
-        if (!__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
-            __classPrivateFieldSet$9(this, _RTCEndpoint_disconnectListener, listener, "f");
+        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
+            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, "f");
         }
         else {
             throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
         }
     }
     receive(listener) {
-        if (__classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f")) {
+        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
             throw new Error('You have already set a listener for this RTC Endpoint.');
         }
-        __classPrivateFieldSet$9(this, _RTCEndpoint_processAction, listener, "f");
+        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, "f");
     }
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
@@ -8552,12 +8573,12 @@ _RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = ne
 
 var strategy$1 = {};
 
-var __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -8578,11 +8599,11 @@ class EndpointStrategy {
             return this.getEndpointById(endpointId).send(action, payload);
         };
         this.close = async () => {
-            if (__classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f")) {
-                __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
-                __classPrivateFieldSet$8(this, _EndpointStrategy_endpointMap, new Map(), "f");
+            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
+                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
+                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), "f");
             }
-            __classPrivateFieldSet$8(this, _EndpointStrategy_connected, false, "f");
+            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, "f");
         };
         this.isValidEndpointPayload = validateEndpoint;
     }
@@ -8590,39 +8611,39 @@ class EndpointStrategy {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
     receive(listener) {
-        if (__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")) {
+        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
             throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);
         }
-        __classPrivateFieldSet$8(this, _EndpointStrategy_processAction, listener, "f");
+        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, "f");
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")));
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")));
     }
     getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
+        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
         if (!endpoint) {
             throw new Error(`Client with endpoint id ${endpointId} is not connected`);
         }
         return endpoint;
     }
     get connected() {
-        return __classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f");
+        return __classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f");
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
+        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f")) {
+        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
             console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);
             return;
         }
         const clientStrat = new this.EndpointType(payload);
-        if (__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")) {
-            clientStrat.receive(__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f"));
+        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
+            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f"));
         }
-        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
     }
     async closeEndpoint(endpointId) {
-        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
+        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
     }
 }
 strategy$1.EndpointStrategy = EndpointStrategy;
@@ -8649,11 +8670,11 @@ var iceManager = {};
 
 Object.defineProperty(iceManager, "__esModule", { value: true });
 iceManager.RTCICEManager = void 0;
-const base_1$i = base;
+const base_1$h = base;
 /*
 Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
 */
-class RTCICEManager extends base_1$i.EmitterBase {
+class RTCICEManager extends base_1$h.EmitterBase {
     constructor(wire) {
         super(wire, 'channel');
         this.ensureChannelOpened = (channel) => {
@@ -8804,12 +8825,12 @@ function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {
 }
 runtimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;
 
-var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -8851,18 +8872,18 @@ class ChannelProvider extends channel_1.ChannelBase {
      * a read-only array containing all the identities of connecting clients.
      */
     get connections() {
-        return [...__classPrivateFieldGet$9(this, _ChannelProvider_connections, "f")];
+        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, "f")];
     }
     static handleClientDisconnection(channel, payload) {
         const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
         if (removeById) {
-            __classPrivateFieldGet$9(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
         }
         else {
             const multipleRemoves = channel.connections.filter((identity) => {
                 return identity.uuid === payload.uuid && identity.name === payload.name;
             });
-            multipleRemoves.forEach(__classPrivateFieldGet$9(channel, _ChannelProvider_removeEndpoint, "f"));
+            multipleRemoves.forEach(__classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, "f"));
         }
         channel.disconnectListener(payload);
     }
@@ -8872,15 +8893,15 @@ class ChannelProvider extends channel_1.ChannelBase {
     /**
      * @internal
      */
-    constructor(providerIdentity, wire, strategy) {
+    constructor(providerIdentity, close, strategy) {
         super();
         _ChannelProvider_connections.set(this, void 0);
         _ChannelProvider_protectedObj.set(this, void 0);
         _ChannelProvider_strategy.set(this, void 0);
         _ChannelProvider_removeEndpoint.set(this, (identity) => {
             const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
-            __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
-            __classPrivateFieldSet$7(this, _ChannelProvider_connections, remainingConnections, "f");
+            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, "f");
         });
         // Must be bound.
         this.processAction = async (action, payload, senderIdentity) => {
@@ -8894,17 +8915,17 @@ class ChannelProvider extends channel_1.ChannelBase {
             return super.processAction(action, payload, senderIdentity);
         };
         _ChannelProvider_close.set(this, () => {
-            __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").close();
+            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").close();
             const remove = ChannelProvider.removalMap.get(this);
             if (remove) {
                 remove();
             }
         });
-        __classPrivateFieldSet$7(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, wire), "f");
+        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
         this.connectListener = () => undefined;
         this.disconnectListener = () => undefined;
-        __classPrivateFieldSet$7(this, _ChannelProvider_connections, [], "f");
-        __classPrivateFieldSet$7(this, _ChannelProvider_strategy, strategy, "f");
+        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, "f");
         strategy.receive(this.processAction);
     }
     /**
@@ -8935,13 +8956,13 @@ class ChannelProvider extends channel_1.ChannelBase {
      */
     dispatch(to, action, payload) {
         const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);
-        if (endpointId && __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
-            return __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
+        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
         }
         return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
     }
     async processConnection(senderId, payload) {
-        __classPrivateFieldGet$9(this, _ChannelProvider_connections, "f").push(senderId);
+        __classPrivateFieldGet$8(this, _ChannelProvider_connections, "f").push(senderId);
         return this.connectListener(senderId, payload);
     }
     /**
@@ -8964,7 +8985,7 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     publish(action, payload) {
-        return this.connections.map((to) => __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
     }
     /**
      * Register a listener that is called on every new client connection.
@@ -9038,11 +9059,11 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     async destroy() {
-        const protectedObj = __classPrivateFieldGet$9(this, _ChannelProvider_protectedObj, "f");
-        const { channelName } = protectedObj.providerIdentity;
-        __classPrivateFieldSet$7(this, _ChannelProvider_connections, [], "f");
-        await protectedObj.wire.sendAction('destroy-channel', { channelName });
-        __classPrivateFieldGet$9(this, _ChannelProvider_close, "f").call(this);
+        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, "f");
+        protectedObj.providerIdentity;
+        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
+        await protectedObj.close();
+        __classPrivateFieldGet$8(this, _ChannelProvider_close, "f").call(this);
     }
     /**
      * Returns an array with info on every Client connected to the Provider
@@ -9112,7 +9133,7 @@ class ChannelProvider extends channel_1.ChannelBase {
     getEndpointIdForOpenFinId(clientIdentity, action) {
         const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
         if (matchingConnections.length >= 2) {
-            const protectedObj = __classPrivateFieldGet$9(this, _ChannelProvider_protectedObj, "f");
+            const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, "f");
             const { uuid, name } = clientIdentity;
             const providerUuid = protectedObj?.providerIdentity.uuid;
             const providerName = protectedObj?.providerIdentity.name;
@@ -9133,6 +9154,9 @@ class ChannelProvider extends channel_1.ChannelBase {
     static clientIsMultiRuntime(subscriptionIdentity) {
         return subscriptionIdentity.runtimeUuid !== undefined;
     }
+    static async wireClose(wire, channelName) {
+        await wire.sendAction('destroy-channel', { channelName });
+    }
 }
 provider.ChannelProvider = ChannelProvider;
 _ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = new WeakMap(), _ChannelProvider_strategy = new WeakMap(), _ChannelProvider_removeEndpoint = new WeakMap(), _ChannelProvider_close = new WeakMap();
@@ -9145,13 +9169,13 @@ var messageReceiver = {};
 Object.defineProperty(messageReceiver, "__esModule", { value: true });
 messageReceiver.MessageReceiver = void 0;
 const client_1$1 = client;
-const base_1$h = base;
+const base_1$g = base;
 /*
 This is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.
 It needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.
 If functionality is not about receiving messages, it does not belong here.
 */
-class MessageReceiver extends base_1$h.Base {
+class MessageReceiver extends base_1$g.Base {
     constructor(wire) {
         super(wire);
         this.onmessage = (msg) => {
@@ -9318,13 +9342,13 @@ class CombinedStrategy {
 }
 strategy.default = CombinedStrategy;
 
-var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -9333,7 +9357,7 @@ var _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;
 Object.defineProperty(connectionManager, "__esModule", { value: true });
 connectionManager.ConnectionManager = void 0;
 const exhaustive_1 = exhaustive;
-const base_1$g = base;
+const base_1$f = base;
 const strategy_1 = strategy$3;
 const strategy_2 = strategy$2;
 const ice_manager_1 = iceManager;
@@ -9341,7 +9365,7 @@ const provider_1$1 = provider;
 const message_receiver_1 = messageReceiver;
 const protocol_manager_1 = protocolManager;
 const strategy_3 = strategy;
-class ConnectionManager extends base_1$g.Base {
+class ConnectionManager extends base_1$f.Base {
     static getProtocolOptionsFromStrings(protocols) {
         return protocols.map((protocol) => {
             switch (protocol) {
@@ -9370,8 +9394,8 @@ class ConnectionManager extends base_1$g.Base {
         };
         this.providerMap = new Map();
         this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);
-        __classPrivateFieldSet$6(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
-        __classPrivateFieldSet$6(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
+        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
+        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
     createProvider(options, providerIdentity) {
@@ -9382,7 +9406,7 @@ class ConnectionManager extends base_1$g.Base {
                 case 'rtc':
                     return new strategy_2.RTCStrategy();
                 case 'classic':
-                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f"), 
+                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f"), 
                     // Providers do not have an endpointId, use channelId as endpointId in the strategy.
                     providerIdentity.channelId, providerIdentity);
                 default:
@@ -9402,7 +9426,7 @@ class ConnectionManager extends base_1$g.Base {
             // Should be impossible.
             throw new Error('failed to combine strategies');
         }
-        const channel = new provider_1$1.ChannelProvider(providerIdentity, this.wire, strategy);
+        const channel = new provider_1$1.ChannelProvider(providerIdentity, () => provider_1$1.ChannelProvider.wireClose(this.wire, providerIdentity.channelName), strategy);
         const key = providerIdentity.channelId;
         this.providerMap.set(key, {
             provider: channel,
@@ -9418,7 +9442,7 @@ class ConnectionManager extends base_1$g.Base {
         const supportedProtocols = await Promise.all(protocols.map(async (type) => {
             switch (type) {
                 case 'rtc': {
-                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$8(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
+                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
                     rtcPacket = { rtcClient, channels, channelsOpened };
                     return {
                         type: 'rtc',
@@ -9445,18 +9469,18 @@ class ConnectionManager extends base_1$g.Base {
             routingInfo.endpointId = this.wire.environment.getNextMessageId();
             // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
             // clients that are in the same context as the newly-connected client.
-            __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
+            __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
         }
         const answer = routingInfo.answer ?? {
             supportedProtocols: [{ type: 'classic', version: 1 }]
         };
         const createStrategyFromAnswer = async (protocol) => {
             if (protocol.type === 'rtc' && rtcPacket) {
-                await __classPrivateFieldGet$8(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
+                await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
                 return new strategy_2.RTCStrategy();
             }
             if (protocol.type === 'classic') {
-                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
+                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
             }
             return null;
         };
@@ -9524,7 +9548,7 @@ class ConnectionManager extends base_1$g.Base {
             clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
                 const answer = await accumP;
                 if (protocolToUse.type === 'rtc') {
-                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$8(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
+                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
                     answer.supportedProtocols.push({
                         type: 'rtc',
                         version: strategy_2.RTCInfo.version,
@@ -9572,13 +9596,13 @@ _ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnec
  *
  * @packageDocumentation
  */
-var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -9589,7 +9613,7 @@ channel$1.Channel = void 0;
 /* eslint-disable no-console */
 const events_1$5 = require$$0;
 const lazy_1$1 = lazy;
-const base_1$f = base;
+const base_1$e = base;
 const client_1 = client;
 const connection_manager_1 = connectionManager;
 const provider_1 = provider;
@@ -9620,7 +9644,7 @@ function retryDelay(count) {
  *  * {@link Channel.onChannelConnect onChannelConnect(listener)}
  *  * {@link Channel.onChannelDisconnect onChannelDisconnect(listener)}
  */
-class Channel extends base_1$f.EmitterBase {
+class Channel extends base_1$e.EmitterBase {
     /**
      * @internal
      */
@@ -9635,11 +9659,11 @@ class Channel extends base_1$f.EmitterBase {
                     client_1.ChannelClient.handleProviderDisconnect(eventPayload);
                 }),
                 this.on('connected', (...args) => {
-                    __classPrivateFieldGet$7(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").emit('connected', ...args);
                 })
             ]).catch(() => new Error('error setting up channel connection listeners'));
         }));
-        __classPrivateFieldSet$5(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
+        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
     /**
      *
@@ -9714,7 +9738,7 @@ class Channel extends base_1$f.EmitterBase {
                         resolve(true);
                     }
                 };
-                __classPrivateFieldGet$7(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
             });
             try {
                 if (retryInfo.count > 0) {
@@ -9746,7 +9770,7 @@ class Channel extends base_1$f.EmitterBase {
             finally {
                 retryInfo.count += 1;
                 // in case of other errors, remove our listener
-                __classPrivateFieldGet$7(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
             }
         } while (shouldWait); // If we're waiting we retry the above loop
         // Should wait was false, no channel was found.
@@ -9805,12 +9829,12 @@ class Channel extends base_1$f.EmitterBase {
     async connect(channelName, options = {}) {
         // Make sure we don't connect before listeners are set up
         // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
-        await __classPrivateFieldGet$7(this, _Channel_readyToConnect, "f").getValue();
+        await __classPrivateFieldGet$6(this, _Channel_readyToConnect, "f").getValue();
         if (!channelName || typeof channelName !== 'string') {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
         const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
-        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$7(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createClientOffer(opts);
         let connectionUrl;
         if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
             connectionUrl = (await this.fin.me.getInfo()).url;
@@ -9822,8 +9846,8 @@ class Channel extends base_1$f.EmitterBase {
             connectionUrl
         };
         const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
-        const strategy = await __classPrivateFieldGet$7(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-        const channel = new client_1.ChannelClient(routingInfo, this.wire, strategy);
+        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);
         // It is the client's responsibility to handle endpoint disconnection to the provider.
         // If the endpoint dies, the client will force a disconnection through the core.
         // The provider does not care about endpoint disconnection.
@@ -9891,7 +9915,7 @@ class Channel extends base_1$f.EmitterBase {
             throw new Error('Please provide a channelName to create a channel');
         }
         const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
-        const channel = __classPrivateFieldGet$7(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
+        const channel = __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
         // TODO: fix typing (internal)
         // @ts-expect-error
         this.on('client-disconnected', (eventPayload) => {
@@ -9915,7 +9939,7 @@ interappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;
  * @packageDocumentation
  */
 const events_1$4 = require$$0;
-const base_1$e = base;
+const base_1$d = base;
 const ref_counter_1 = refCounter;
 const index_1$2 = channel$1;
 const validate_1$3 = validate;
@@ -9923,7 +9947,7 @@ const validate_1$3 = validate;
  * A messaging bus that allows for pub/sub messaging between different applications.
  *
  */
-class InterApplicationBus extends base_1$e.Base {
+class InterApplicationBus extends base_1$d.Base {
     /**
      * @internal
      */
@@ -10129,12 +10153,12 @@ var clipboard = {};
  */
 Object.defineProperty(clipboard, "__esModule", { value: true });
 clipboard.Clipboard = void 0;
-const base_1$d = base;
+const base_1$c = base;
 /**
  * The Clipboard API allows reading and writing to the clipboard in multiple formats.
  *
  */
-class Clipboard extends base_1$d.Base {
+class Clipboard extends base_1$c.Base {
     /**
      * Writes data into the clipboard as plain text
      * @param writeObj The object for writing data into the clipboard
@@ -10323,7 +10347,7 @@ var Instance$4 = {};
 Object.defineProperty(Instance$4, "__esModule", { value: true });
 Instance$4.ExternalApplication = void 0;
 /* eslint-disable import/prefer-default-export */
-const base_1$c = base;
+const base_1$b = base;
 /**
  * An ExternalApplication object representing native language adapter connections to the runtime. Allows
  * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.
@@ -10334,7 +10358,7 @@ const base_1$c = base;
  * - Processes started via `System.launchExternalApplication`
  * - Processes monitored via `System.monitorExternalProcess`
  */
-class ExternalApplication extends base_1$c.EmitterBase {
+class ExternalApplication extends base_1$b.EmitterBase {
     /**
      * @internal
      */
@@ -10362,12 +10386,12 @@ Instance$4.ExternalApplication = ExternalApplication;
 
 Object.defineProperty(Factory$5, "__esModule", { value: true });
 Factory$5.ExternalApplicationModule = void 0;
-const base_1$b = base;
+const base_1$a = base;
 const Instance_1$4 = Instance$4;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.
  */
-class ExternalApplicationModule extends base_1$b.Base {
+class ExternalApplicationModule extends base_1$a.Base {
     /**
      * Asynchronously returns an External Application object that represents an external application.
      * <br>It is possible to wrap a process that does not yet exist, (for example, to listen for startup-related events)
@@ -10449,7 +10473,7 @@ var Instance$3 = {};
 Object.defineProperty(Instance$3, "__esModule", { value: true });
 Instance$3._Frame = void 0;
 /* eslint-disable import/prefer-default-export */
-const base_1$a = base;
+const base_1$9 = base;
 /**
  * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
  * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
@@ -10470,7 +10494,7 @@ const base_1$a = base;
  * The fin.Frame namespace represents a way to interact with `iframes` and facilitates the discovery of current context
  * (iframe or main window) as well as the ability to listen for {@link OpenFin.FrameEvents frame-specific events}.
  */
-class _Frame extends base_1$a.EmitterBase {
+class _Frame extends base_1$9.EmitterBase {
     /**
      * @internal
      */
@@ -10516,13 +10540,13 @@ Instance$3._Frame = _Frame;
 
 Object.defineProperty(Factory$4, "__esModule", { value: true });
 Factory$4._FrameModule = void 0;
-const base_1$9 = base;
+const base_1$8 = base;
 const validate_1$2 = validate;
 const Instance_1$3 = Instance$3;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link _Frame} class, available under `fin.Frame`.
  */
-class _FrameModule extends base_1$9.Base {
+class _FrameModule extends base_1$8.Base {
     /**
      * Asynchronously returns an API handle for the given Frame identity.
      *
@@ -10643,12 +10667,12 @@ var globalHotkey = {};
 
 Object.defineProperty(globalHotkey, "__esModule", { value: true });
 globalHotkey.GlobalHotkey = void 0;
-const base_1$8 = base;
+const base_1$7 = base;
 /**
  * The GlobalHotkey module can register/unregister a global hotkeys.
  *
  */
-class GlobalHotkey extends base_1$8.EmitterBase {
+class GlobalHotkey extends base_1$7.EmitterBase {
     /**
      * @internal
      */
@@ -10782,7 +10806,7 @@ var Factory$3 = {};
 
 var Instance$2 = {};
 
-var __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -10791,7 +10815,7 @@ var _Platform_connectToProvider;
 Object.defineProperty(Instance$2, "__esModule", { value: true });
 Instance$2.Platform = void 0;
 /* eslint-disable import/prefer-default-export, no-undef */
-const base_1$7 = base;
+const base_1$6 = base;
 const validate_1$1 = validate;
 // Reuse clients to avoid overwriting already-registered client in provider
 const clientMap = new Map();
@@ -10800,7 +10824,7 @@ const clientMap = new Map();
  * Enables taking snapshots of itself and applying them to restore a previous configuration
  * as well as listen to {@link OpenFin.PlatformEvents platform events}.
  */
-class Platform extends base_1$7.EmitterBase {
+class Platform extends base_1$6.EmitterBase {
     /**
      * @internal
      */
@@ -10815,7 +10839,7 @@ class Platform extends base_1$7.EmitterBase {
             const target = identity || this.identity;
             const { uuid } = target;
             if (!clientMap.has(uuid)) {
-                const clientPromise = __classPrivateFieldGet$6(this, _Platform_connectToProvider, "f").call(this, uuid);
+                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, "f").call(this, uuid);
                 clientMap.set(uuid, clientPromise);
             }
             // we set it above
@@ -11640,7 +11664,7 @@ function overrideFromComposables(...overrides) {
 commonUtils.overrideFromComposables = overrideFromComposables;
 commonUtils.default = { isValidPresetType };
 
-var __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -11650,7 +11674,7 @@ Object.defineProperty(Instance$1, "__esModule", { value: true });
 Instance$1.Layout = void 0;
 const lazy_1 = lazy;
 const validate_1 = validate;
-const base_1$6 = base;
+const base_1$5 = base;
 const common_utils_1 = commonUtils;
 const layout_entities_1 = layoutEntities;
 const layout_constants_1$1 = layout_constants;
@@ -11786,7 +11810,7 @@ const layout_constants_1$1 = layout_constants;
  * }
  * ```
  */
-class Layout extends base_1$6.Base {
+class Layout extends base_1$5.Base {
     /**
      * @internal
      */
@@ -12007,7 +12031,7 @@ class Layout extends base_1$6.Base {
         this.wire.sendAction('layout-get-root-item').catch(() => {
             // don't expose
         });
-        const client = await __classPrivateFieldGet$5(this, _Layout_layoutClient, "f").getValue();
+        const client = await __classPrivateFieldGet$4(this, _Layout_layoutClient, "f").getValue();
         const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);
         return layout_entities_1.LayoutNode.getEntity(root, client);
     }
@@ -12015,12 +12039,12 @@ class Layout extends base_1$6.Base {
 Instance$1.Layout = Layout;
 _Layout_layoutClient = new WeakMap();
 
-var __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -12029,13 +12053,13 @@ var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateF
 var _LayoutModule_instances, _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager, _LayoutModule_getLayoutManagerSpy, _LayoutModule_getSafeLayoutManager;
 Object.defineProperty(Factory$2, "__esModule", { value: true });
 Factory$2.LayoutModule = void 0;
-const base_1$5 = base;
+const base_1$4 = base;
 const Instance_1$2 = Instance$1;
 const layout_constants_1 = layout_constants;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.
  */
-class LayoutModule extends base_1$5.Base {
+class LayoutModule extends base_1$4.Base {
     constructor() {
         super(...arguments);
         _LayoutModule_instances.add(this);
@@ -12086,19 +12110,19 @@ class LayoutModule extends base_1$5.Base {
             if (!this.fin.me.isWindow) {
                 throw new Error('Layout.init can only be called from a Window context.');
             }
-            else if (__classPrivateFieldGet$4(this, _LayoutModule_layoutInitializationAttempted, "f")) {
+            else if (__classPrivateFieldGet$3(this, _LayoutModule_layoutInitializationAttempted, "f")) {
                 throw new Error('Layout.init was already called, please use Layout.create to add additional layouts.');
             }
-            __classPrivateFieldSet$4(this, _LayoutModule_layoutInitializationAttempted, true, "f");
+            __classPrivateFieldSet$3(this, _LayoutModule_layoutInitializationAttempted, true, "f");
             // preload the client
             await this.fin.Platform.getCurrentSync().getClient();
-            __classPrivateFieldSet$4(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), "f");
-            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$4(this, _LayoutModule_layoutManager, "f"), options);
+            __classPrivateFieldSet$3(this, _LayoutModule_layoutManager, await this.wire.environment.initLayoutManager(this.fin, this.wire, options), "f");
+            await this.wire.environment.applyLayoutSnapshot(this.fin, __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f"), options);
             if (!options.layoutManagerOverride) {
                 // CORE-1081 to be removed when we actually delete the `layoutManager` prop
                 // in single-layout case, we return the undocumented layoutManager type
                 const layoutIdentity = { layoutName: layout_constants_1.DEFAULT_LAYOUT_KEY, ...this.fin.me.identity };
-                return __classPrivateFieldGet$4(this, _LayoutModule_getLayoutManagerSpy, "f").call(this, layoutIdentity);
+                return __classPrivateFieldGet$3(this, _LayoutModule_getLayoutManagerSpy, "f").call(this, layoutIdentity);
             }
             return this.wrapSync(this.fin.me.identity);
         };
@@ -12127,13 +12151,13 @@ class LayoutModule extends base_1$5.Base {
          * @returns
          */
         this.getCurrentLayoutManagerSync = () => {
-            return __classPrivateFieldGet$4(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);
+            return __classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.getCurrentLayoutManagerSync()`);
         };
         this.create = async (options) => {
-            return this.wire.environment.createLayout(__classPrivateFieldGet$4(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);
+            return this.wire.environment.createLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.create()`), options);
         };
         this.destroy = async (layoutIdentity) => {
-            return this.wire.environment.destroyLayout(__classPrivateFieldGet$4(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);
+            return this.wire.environment.destroyLayout(__classPrivateFieldGet$3(this, _LayoutModule_instances, "m", _LayoutModule_getSafeLayoutManager).call(this, `fin.Platform.Layout.destroy()`), layoutIdentity);
         };
     }
     /**
@@ -12232,10 +12256,10 @@ class LayoutModule extends base_1$5.Base {
 }
 Factory$2.LayoutModule = LayoutModule;
 _LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {
-    if (!__classPrivateFieldGet$4(this, _LayoutModule_layoutManager, "f")) {
+    if (!__classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f")) {
         throw new Error(`You must call init before using the API ${method}`);
     }
-    return __classPrivateFieldGet$4(this, _LayoutModule_layoutManager, "f");
+    return __classPrivateFieldGet$3(this, _LayoutModule_layoutManager, "f");
 };
 
 (function (exports) {
@@ -12272,13 +12296,13 @@ _LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layou
 
 Object.defineProperty(Factory$3, "__esModule", { value: true });
 Factory$3.PlatformModule = void 0;
-const base_1$4 = base;
+const base_1$3 = base;
 const Instance_1$1 = Instance$2;
 const index_1$1 = layout;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link Platform} class, available under `fin.Platform`.
  */
-class PlatformModule extends base_1$4.Base {
+class PlatformModule extends base_1$3.Base {
     /**
      * @internal
      */
@@ -12849,7 +12873,7 @@ function requireSessionContextGroupBroker () {
 	return SessionContextGroupBroker;
 }
 
-var utils$1 = {};
+var utils$3 = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -12912,7 +12936,7 @@ var utils$1 = {};
 	    };
 	};
 	exports.wrapIntentHandler = wrapIntentHandler; 
-} (utils$1));
+} (utils$3));
 
 var PrivateChannelProvider = {};
 
@@ -13215,14 +13239,15 @@ function requireInteropBroker () {
 	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
 	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 	};
-	var _InteropBroker_fdc3Info, _InteropBroker_contextGroups;
+	var _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;
 	Object.defineProperty(InteropBroker, "__esModule", { value: true });
 	InteropBroker.InteropBroker = void 0;
 	const base_1 = base;
 	const SessionContextGroupBroker_1 = requireSessionContextGroupBroker();
-	const utils_1 = utils$1;
+	const utils_1 = utils$3;
 	const lodash_1 = require$$3;
 	const PrivateChannelProvider_1 = requirePrivateChannelProvider();
+	const lazy_1 = lazy;
 	const defaultContextGroups = [
 	    {
 	        id: 'green',
@@ -13390,12 +13415,15 @@ function requireInteropBroker () {
 	    /**
 	     * @internal
 	     */
-	    constructor(wire, getProvider, options) {
+	    constructor(wire, createProvider, options) {
 	        // Tip from Pierre and Michael from the overrideCheck work: Don't use bound methods for overrideable InteropBroker functions.
 	        super(wire);
-	        this.getProvider = getProvider;
 	        _InteropBroker_fdc3Info.set(this, void 0);
 	        _InteropBroker_contextGroups.set(this, void 0);
+	        _InteropBroker_providerPromise.set(this, void 0);
+	        this.getProvider = () => {
+	            return __classPrivateFieldGet(this, _InteropBroker_providerPromise, "f").getValue();
+	        };
 	        this.interopClients = new Map();
 	        this.contextGroupsById = new Map();
 	        __classPrivateFieldSet(this, _InteropBroker_contextGroups, options.contextGroups ?? [...defaultContextGroups], "f");
@@ -13406,6 +13434,7 @@ function requireInteropBroker () {
 	        this.intentClientMap = new Map();
 	        this.lastContextMap = new Map();
 	        this.sessionContextGroupMap = new Map();
+	        __classPrivateFieldSet(this, _InteropBroker_providerPromise, new lazy_1.Lazy(createProvider), "f");
 	        this.setContextGroupMap();
 	        this.setupChannelProvider();
 	    }
@@ -14489,35 +14518,35 @@ function requireInteropBroker () {
 	    }
 	};
 	InteropBroker.InteropBroker = InteropBroker$1;
-	_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap();
+	_InteropBroker_fdc3Info = new WeakMap(), _InteropBroker_contextGroups = new WeakMap(), _InteropBroker_providerPromise = new WeakMap();
 	return InteropBroker;
 }
 
-var InteropClient$1 = {};
+var InteropClient = {};
 
 var SessionContextGroupClient$1 = {};
 
-var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _SessionContextGroupClient_clientPromise;
 Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
-const base_1$3 = base;
-const utils_1$3 = utils$1;
-class SessionContextGroupClient extends base_1$3.Base {
+const base_1$2 = base;
+const utils_1$2 = utils$3;
+class SessionContextGroupClient extends base_1$2.Base {
     constructor(wire, client, id) {
         super(wire);
         _SessionContextGroupClient_clientPromise.set(this, void 0);
         this.id = id;
-        __classPrivateFieldSet$3(this, _SessionContextGroupClient_clientPromise, client, "f");
+        __classPrivateFieldSet$2(this, _SessionContextGroupClient_clientPromise, client, "f");
     }
     /**
      * Sets a context for the session context group.
@@ -14529,7 +14558,7 @@ class SessionContextGroupClient extends base_1$3.Base {
         this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet$3(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
             sessionContextGroupId: this.id,
             context
@@ -14539,7 +14568,7 @@ class SessionContextGroupClient extends base_1$3.Base {
         this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet$3(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
             sessionContextGroupId: this.id,
             type
@@ -14552,20 +14581,20 @@ class SessionContextGroupClient extends base_1$3.Base {
         if (typeof contextHandler !== 'function') {
             throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
         }
-        const client = await __classPrivateFieldGet$3(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         let handlerId;
         if (contextType) {
-            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$3.generateId)()}`;
+            handlerId = `sessionContextHandler:invoke-${this.id}-${contextType}-${(0, utils_1$2.generateId)()}`;
         }
         else {
             handlerId = `sessionContextHandler:invoke-${this.id}`;
         }
-        client.register(handlerId, (0, utils_1$3.wrapContextHandler)(contextHandler, handlerId));
+        client.register(handlerId, (0, utils_1$2.wrapContextHandler)(contextHandler, handlerId));
         await client.dispatch(`sessionContextGroup:handlerAdded-${this.id}`, { handlerId, contextType });
         return { unsubscribe: await this.createUnsubscribeCb(handlerId) };
     }
     async createUnsubscribeCb(handlerId) {
-        const client = await __classPrivateFieldGet$3(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$2(this, _SessionContextGroupClient_clientPromise, "f");
         return async () => {
             client.remove(handlerId);
             await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
@@ -14574,654 +14603,1810 @@ class SessionContextGroupClient extends base_1$3.Base {
     getUserInstance() {
         return {
             id: this.id,
-            setContext: (0, utils_1$3.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
-            getCurrentContext: (0, utils_1$3.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
-            addContextHandler: (0, utils_1$3.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
+            setContext: (0, utils_1$2.wrapInTryCatch)(this.setContext.bind(this), 'Failed to set context: '),
+            getCurrentContext: (0, utils_1$2.wrapInTryCatch)(this.getCurrentContext.bind(this), 'Failed to get context: '),
+            addContextHandler: (0, utils_1$2.wrapInTryCatch)(this.addContextHandler.bind(this), 'Failed to add context handler: ')
         };
     }
 }
 SessionContextGroupClient$1.default = SessionContextGroupClient;
 _SessionContextGroupClient_clientPromise = new WeakMap();
 
-var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
-Object.defineProperty(InteropClient$1, "__esModule", { value: true });
-InteropClient$1.InteropClient = void 0;
-const base_1$2 = base;
-const SessionContextGroupClient_1 = SessionContextGroupClient$1;
-const utils_1$2 = utils$1;
-/**
- * The Interop Client API is broken up into two groups:
- *
- * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
- *
- * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
- *
- * ---
- *
- * All APIs are available at the `fin.me.interop` namespace.
- *
- * ---
- *
- * **You only need 2 things to participate in Interop Context Grouping:**
- * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
- * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
- *
- * ---
- *
- * ##### Constructor
- * Returned by {@link Interop.connectSync Interop.connectSync}.
- *
- * ---
- *
- * ##### Interop methods intended for Views
- *
- *
- * **Context Groups API**
- *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
- *  * {@link InteropClient#setContext setContext(context)}
- *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
- *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
- *
- *
- * **Intents API**
- *  * {@link InteropClient#fireIntent fireIntent(intent)}
- *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
- *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
- *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
- *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
- *
- * ##### Interop methods intended for Windows
- *  * {@link InteropClient#getContextGroups getContextGroups()}
- *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
- *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
- *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
- *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
- *
- */
-class InteropClient extends base_1$2.Base {
-    /**
-     * @internal
-     */
-    constructor(wire, name, interopConfig = {}) {
-        super(wire);
-        _InteropClient_clientPromise.set(this, void 0);
-        _InteropClient_sessionContextGroups.set(this, void 0);
-        __classPrivateFieldSet$2(this, _InteropClient_sessionContextGroups, new Map(), "f");
-        __classPrivateFieldSet$2(this, _InteropClient_clientPromise, this.wire.environment.whenReady().then(() => {
-            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
-                payload: interopConfig
-            });
-        }), "f");
+var fdc31_2 = {};
+
+var fdc3Common = {};
+
+var utils$2 = {};
+
+var PrivateChannelClient$1 = {};
+
+Object.defineProperty(PrivateChannelClient$1, "__esModule", { value: true });
+PrivateChannelClient$1.PrivateChannelClient = void 0;
+const utils$1 = utils$3;
+class PrivateChannelClient {
+    constructor(client, id) {
+        this.id = id;
+        this.client = client;
+        this.listeners = new Map();
     }
-    /*
-    Client APIs
-    */
-    /**
-     * Sets a context for the context group of the current entity.
-     *
-     * @remarks The entity must be part of a context group in order set a context.
-     *
-     * @param context - New context to set.
-     *
-     * @example
-     * ```js
-     * setInstrumentContext = async (ticker) => {
-     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})
-     * }
-     *
-     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument
-     * instrumentElement.on('click', (evt) => {
-     *     setInstrumentContext(evt.ticker)
-     * })
-     * ```
-     */
-    async setContext(context) {
-        this.wire.sendAction('interop-client-set-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('setContext', { context });
+    async broadcast(context) {
+        return this.client.dispatch('broadcast', { context });
     }
-    /**
-     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,
-     * it will receive all of its declared contexts.
-     *
-     * @param handler - Handler for incoming context.
-     * @param contextType - The type of context you wish to handle.
-     *
-     * @example
-     * ```js
-     * function handleIncomingContext(contextInfo) {
-     *     const { type, id } = contextInfo;
-     *     switch (type) {
-     *         case 'instrument':
-     *             handleInstrumentContext(contextInfo);
-     *             break;
-     *         case 'country':
-     *             handleCountryContext(contextInfo);
-     *             break;
-     *
-     *         default:
-     *             break;
-     *     }
-     * }
-     *
-     *
-     * function handleInstrumentContext(contextInfo) {
-     *     const { type, id } = contextInfo;
-     *     console.log('contextInfo for instrument', contextInfo)
-     * }
-     *
-     * function handleCountryContext(contextInfo) {
-     *     const { type, id } = contextInfo;
-     *     console.log('contextInfo for country', contextInfo)
-     * }
-     *
-     * fin.me.interop.addContextHandler(handleIncomingContext);
-     * ```
-     *
-     *
-     * We are also testing the ability to add a context handler for specific contexts. If you would like to use
-     * this, please make sure you add your context handlers at the top level of your application, on a page that
-     * does not navigate/reload/re-render, to avoid memory leaks.  This feature is experimental:
-     *
-     * ```js
-     * function handleInstrumentContext(contextInfo) {
-     *     const { type, id } = contextInfo;
-     *     console.log('contextInfo for instrument', contextInfo)
-     * }
-     *
-     * function handleCountryContext(contextInfo) {
-     *     const { type, id } = contextInfo;
-     *     console.log('contextInfo for country', contextInfo)
-     * }
-     *
-     *
-     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')
-     * fin.me.interop.addContextHandler(handleCountryContext, 'country')
-     * ```
-     */
-    async addContextHandler(handler, contextType) {
-        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
-            // don't expose, analytics-only call
-        });
+    async getCurrentContext(contextType) {
+        return this.client.dispatch('getCurrentContext', { contextType });
+    }
+    async addContextListener(contextType, handler) {
         if (typeof handler !== 'function') {
-            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+            throw new Error("Non-function argument passed to the second parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
         }
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
         let handlerId;
         if (contextType) {
-            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1$2.generateId)()}`;
-            console.warn(`Warning: By providing a contextType (${contextType}), you are using the experimental addContextHandler. To avoid issues, make sure you are adding your context handlers at the top level in your application.`);
+            handlerId = `contextHandler:invoke-${this.id}-${contextType}-${utils$1.generateId()}`;
         }
         else {
-            handlerId = 'invokeContextHandler';
+            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;
         }
-        const wrappedHandler = (0, utils_1$2.wrapContextHandler)(handler, handlerId);
-        client.register(handlerId, wrappedHandler);
-        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
-        return {
-            unsubscribe: async () => {
-                client.remove(handlerId);
-                await client.dispatch('removeContextHandler', { handlerId });
-            }
+        this.client.register(handlerId, utils$1.wrapContextHandler(handler, handlerId));
+        const listener = { unsubscribe: await this.createContextUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        await this.client.dispatch(`contextHandlerAdded`, { handlerId, contextType });
+        return listener;
+    }
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
         };
     }
-    /*
-    Platform Window APIs
-    */
-    /**
-     * Returns the Interop-Broker-defined context groups available for an entity to join.
-     * Used by Platform Windows.
-     *
-     * @example
-     * ```js
-     * fin.me.interop.getContextGroups()
-     *         .then(contextGroups => {
-     *             contextGroups.forEach(contextGroup => {
-     *                 console.log(contextGroup.displayMetadata.name)
-     *                 console.log(contextGroup.displayMetadata.color)
-     *             })
-     *         })
-     * ```
-     */
-    async getContextGroups() {
-        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('getContextGroups');
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
     }
-    /**
-     * Join all Interop Clients at the given identity to context group `contextGroupId`.
-     * If no target is specified, it adds the sender to the context group.
-     *
-     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
-     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
-     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
-     * Used by Platform Windows.
-     *
-     * @param contextGroupId - Id of the context group.
-     * @param target - Identity of the entity you wish to join to a context group.
-     *
-     * @example
-     * ```js
-     * joinViewToContextGroup = async (contextGroupId, view) => {
-     *     await fin.me.interop.joinContextGroup(contextGroupId, view);
-     * }
-     *
-     * getLastFocusedView()
-     *     .then(lastFocusedViewIdentity => {
-     *         joinViewToContextGroup('red', lastFocusedViewIdentity)
-     *     })
-     * ```
-     */
-    async joinContextGroup(contextGroupId, target) {
-        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
-            // don't expose, analytics-only call
+    onAddContextListener(handler) {
+        const handlerId = `onContextHandlerAdded:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onAddContextHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onDisconnect(handler) {
+        const handlerId = `onDisconnect:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onDisconnectHandlerAdded`, { handlerId });
+        return listener;
+    }
+    onUnsubscribe(handler) {
+        const handlerId = `onUnsubscribe:invoke-${this.id}-${utils$1.generateId()}`;
+        this.client.register(handlerId, handler);
+        const listener = { unsubscribe: this.createNonStandardUnsubscribeCb(handlerId) };
+        this.listeners.set(handlerId, listener);
+        this.client.dispatch(`onUnsubscribeHandlerAdded`, { handlerId });
+        return listener;
+    }
+    async cleanUpAllSubs() {
+        const listenerUnsubscribers = Array.from(this.listeners.keys());
+        listenerUnsubscribers.forEach((handlerId) => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
         });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for joinContextGroup.');
+    }
+    async disconnect() {
+        try {
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
+        }
+        catch (error) {
+            throw new Error(error.message);
         }
-        return client.dispatch('joinContextGroup', { contextGroupId, target });
-    }
-    /**
-     * Removes the specified target from a context group.
-     * If no target is specified, it removes the sender from their context group.
-     * Used by Platform Windows.
-     *
-     * @param target - Identity of the entity you wish to join to a context group.
-     *
-     * @example
-     * ```js
-     * removeViewFromContextGroup = async (view) => {
-     *     await fin.me.interop.removeFromContextGroup(view);
-     * }
-     *
-     * getLastFocusedView()
-     *     .then(lastFocusedViewIdentity => {
-     *         removeViewFromContextGroup(lastFocusedViewIdentity)
-     *     })
-     * ```
-     */
-    async removeFromContextGroup(target) {
-        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('removeFromContextGroup', { target });
-    }
-    /**
-     * Gets all clients for a context group.
-     *
-     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
-     *
-     * Returns the Interop-Broker-defined context groups available for an entity to join.
-     * @param contextGroupId - The id of context group you wish to get clients for.
-     *
-     * @example
-     * ```js
-     * fin.me.interop.getAllClientsInContextGroup('red')
-     *     .then(clientsInContextGroup => {
-     *         console.log(clientsInContextGroup)
-     *     })
-     * ```
-     */
-    async getAllClientsInContextGroup(contextGroupId) {
-        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
-        }
-        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
-    }
-    /**
-     * Gets display info for a context group
-     *
-     * @remarks Used by Platform Windows.
-     * @param contextGroupId - The id of context group you wish to get display info for.
-     *
-     * @example
-     * ```js
-     * fin.me.interop.getInfoForContextGroup('red')
-     *     .then(contextGroupInfo => {
-     *         console.log(contextGroupInfo.displayMetadata.name)
-     *         console.log(contextGroupInfo.displayMetadata.color)
-     *     })
-     * ```
-     */
-    async getInfoForContextGroup(contextGroupId) {
-        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
-        }
-        return client.dispatch('getInfoForContextGroup', { contextGroupId });
-    }
-    /**
-     * Sends an intent to the Interop Broker to resolve.
-     * @param intent - The combination of an action and a context that is passed to an application for resolution.
-     *
-     * @example
-     * ```js
-     * // View wants to fire an Intent after a user clicks on a ticker
-     * tickerElement.on('click', (element) => {
-     *     const ticker = element.innerText;
-     *     const intent = {
-     *         name: 'ViewChart',
-     *         context: {type: 'fdc3.instrument', id: { ticker }}
-     *     }
-     *
-     *     fin.me.interop.fireIntent(intent);
-     * })
-     * ```
-     */
-    async fireIntent(intent) {
-        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
-            // don't expose, this is only for api analytics purposes
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('fireIntent', intent);
-    }
-    /**
-     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
-     * @param handler - Registered function meant to handle a specific intent type.
-     * @param intentName - The name of an intent.
-     *
-     * @example
-     * ```js
-     * const intentHandler = (intent) => {
-     *     const { context } = intent;
-     *     myViewChartHandler(context);
-     * };
-     *
-     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');
-     *
-     * function myAppCloseSequence() {
-     *     // to unsubscribe the handler, simply call:
-     *     subscription.unsubscribe();
-     * }
-     * ```
-     */
-    async registerIntentHandler(handler, intentName, options) {
-        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
-            // don't expose, this is only for api analytics purposes
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        const handlerId = `intent-handler-${intentName}`;
-        const wrappedHandler = (0, utils_1$2.wrapIntentHandler)(handler, handlerId);
-        try {
-            await client.register(handlerId, wrappedHandler);
-            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
-        }
-        catch (error) {
-            throw new Error('Unable to register intent handler');
-        }
-        return {
-            unsubscribe: async () => {
-                client.remove(handlerId);
-            }
-        };
-    }
-    /**
-     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
-     * last context of that type.
-     * @param contextType
-     *
-     * @example
-     * ```js
-     * await fin.me.interop.joinContextGroup('yellow');
-     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
-     * const currentContext = await fin.me.interop.getCurrentContext();
-     *
-     * // with a specific context
-     * await fin.me.interop.joinContextGroup('yellow');
-     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});
-     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
-     * const currentContext = await fin.me.interop.getCurrentContext('country');
-     * ```
-     */
-    async getCurrentContext(contextType) {
-        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('getCurrentContext', { contextType });
-    }
-    /**
-     * Get information for a particular Intent from the Interop Broker.
-     *
-     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.
-     * The format for the response will be determined by the App Provider overriding the function.
-     *
-     * @param options
-     *
-     * @example
-     * ```js
-     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');
-     * ```
-     */
-    async getInfoForIntent(options) {
-        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('getInfoForIntent', options);
-    }
-    /**
-     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
-     *
-     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.
-     * The format for the response will be determined by the App Provider overriding the function.
-     *
-     * @param context
-     *
-     * @example
-     * ```js
-     * tickerElement.on('click', (element) => {
-     *     const ticker = element.innerText;
-     *
-     *     const context = {
-     *         type: 'fdc3.instrument',
-     *         id: {
-     *             ticker
-     *         }
-     *     }
-     *
-     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);
-     * })
-     * ```
-     */
-    async getInfoForIntentsByContext(context) {
-        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('getInfoForIntentsByContext', context);
-    }
-    /**
-     * Sends a Context that will be resolved to an Intent by the Interop Broker.
-     * This context accepts a metadata property.
-     *
-     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.
-     * The format for the response will be determined by the App Provider overriding the function.
-     *
-     * @param context
-     *
-     * @example
-     * ```js
-     * tickerElement.on('click', (element) => {
-     *     const ticker = element.innerText;
-     *
-     *     const context = {
-     *         type: 'fdc3.instrument',
-     *         id: {
-     *             ticker
-     *         }
-     *     }
-     *
-     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);
-     * })
-     * ```
-     */
-    async fireIntentForContext(context) {
-        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('fireIntentForContext', context);
-    }
-    /**
-     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
-     * If the sessionContextGroup doesn't exist, one will get created.
-     *
-     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.
-     * @param sessionContextGroupId - Id of the context group.
-     *
-     * @example
-     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:
-     *
-     * My color-picker View:
-     * ```js
-     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
-     *
-     *     const myColorPickerElement = document.getElementById('color-palette-picker');
-     *     myColorPickerElement.addEventListener('change', event => {
-     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });
-     *     });
-     * ```
-     *
-     * In other views:
-     * ```js
-     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
-     *
-     *     const changeColorPalette = ({ selection }) => {
-     *         // change the color palette to the selection
-     *     };
-     *
-     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.
-     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');
-     * ```
-     */
-    async joinSessionContextGroup(sessionContextGroupId) {
-        try {
-            const currentSessionContextGroup = __classPrivateFieldGet$2(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
-            if (currentSessionContextGroup) {
-                return currentSessionContextGroup.getUserInstance();
-            }
-            const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
-                sessionContextGroupId
-            });
-            if (hasConflict) {
-                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
-            }
-            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
-            __classPrivateFieldGet$2(this, _InteropClient_sessionContextGroups, "f").set(sessionContextGroupId, newSessionContextGroup);
-            return newSessionContextGroup.getUserInstance();
-        }
-        catch (error) {
-            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
-            throw error;
-        }
-    }
-    /**
-     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.
-     * Only one listener per Interop Client can be set.
-     * @param listener
-     *
-     * @example
-     * ```js
-     * const listener = (event) => {
-     *     const { type, topic, brokerName} = event;
-     *     console.log(`Disconnected from Interop Broker ${brokerName} `);
-     * }
-     *
-     * await fin.me.interop.onDisconnection(listener);
-     * ```
-     */
-    async onDisconnection(listener) {
-        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {
-            // don't expose, analytics-only call
-        });
-        const client = await __classPrivateFieldGet$2(this, _InteropClient_clientPromise, "f");
-        return client.onDisconnection((event) => {
-            const { uuid } = event;
-            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });
-        });
-    }
-    /**
-     * @internal
-     *
-     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker
-     */
-    static async ferryFdc3Call(interopClient, action, payload) {
-        const client = await __classPrivateFieldGet$2(interopClient, _InteropClient_clientPromise, "f");
-        return client.dispatch(action, payload || null);
     }
 }
-InteropClient$1.InteropClient = InteropClient;
-_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
-
-var overrideCheck = {};
+PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
+
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.getIntentResolution = exports.isChannel = exports.isContext = exports.connectPrivateChannel = exports.buildAppChannelObject = exports.buildPrivateChannelObject = exports.ChannelError = exports.ResultError = exports.UnsupportedChannelApiError = exports.getUnsupportedChannelApis = void 0;
+	const utils_1 = utils$3;
+	const PrivateChannelClient_1 = PrivateChannelClient$1;
+	const lodash_1 = require$$3;
+	const getUnsupportedChannelApis = (channelType) => {
+	    return {
+	        addContextListener: () => {
+	            throw new UnsupportedChannelApiError('Channel.addContextListener', channelType);
+	        },
+	        broadcast: () => {
+	            throw new UnsupportedChannelApiError('Channel.broadcast', channelType);
+	        },
+	        getCurrentContext: () => {
+	            throw new UnsupportedChannelApiError('Channel.getCurrentContext', channelType);
+	        }
+	    };
+	};
+	exports.getUnsupportedChannelApis = getUnsupportedChannelApis;
+	class UnsupportedChannelApiError extends Error {
+	    constructor(apiName, channelType = 'System') {
+	        super(apiName);
+	        this.message = `Calling ${apiName} on an instance of a ${channelType} Channel returned by fdc3.get${channelType}Channels is not supported. If you would like to use a ${channelType} Channel, please use fdc3.joinChannel, fdc3.addContextListener, and fdc3.broadcast instead.`;
+	    }
+	}
+	exports.UnsupportedChannelApiError = UnsupportedChannelApiError;
+	var ResultError;
+	(function (ResultError) {
+	    /** Returned if the `IntentHandler` exited without returning a Promise or that
+	     *  Promise was not resolved with a Context or Channel object.
+	     */
+	    ResultError["NoResultReturned"] = "NoResultReturned";
+	    /** Returned if the `IntentHandler` function processing the raised intent
+	     *  throws an error or rejects the Promise it returned.
+	     */
+	    ResultError["IntentHandlerRejected"] = "IntentHandlerRejected";
+	})(ResultError = exports.ResultError || (exports.ResultError = {}));
+	(function (ChannelError) {
+	    /** Returned if the specified channel is not found when attempting to join a
+	     *  channel via the `joinUserChannel` function of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["NoChannelFound"] = "NoChannelFound";
+	    /** SHOULD be returned when a request to join a user channel or to a retrieve
+	     *  a Channel object via the `joinUserChannel` or `getOrCreateChannel` methods
+	     *  of the DesktopAgent (`fdc3`) object is denied.
+	     */
+	    ChannelError["AccessDenied"] = "AccessDenied";
+	    /** SHOULD be returned when a channel cannot be created or retrieved via the
+	     *  `getOrCreateChannel` method of the DesktopAgent (`fdc3`).
+	     */
+	    ChannelError["CreationFailed"] = "CreationFailed";
+	})(exports.ChannelError || (exports.ChannelError = {}));
+	const buildPrivateChannelObject = (privateChannelClient) => {
+	    let clientDisconnected = false;
+	    const checkIfClientDisconnected = () => {
+	        if (clientDisconnected) {
+	            throw new Error('Private Channel Client has been disconnected from the Private Channel');
+	        }
+	    };
+	    return {
+	        id: privateChannelClient.id,
+	        type: 'private',
+	        broadcast: async (context) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.broadcast(context);
+	        },
+	        getCurrentContext: async (contextType) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.getCurrentContext(contextType);
+	        },
+	        // @ts-expect-error TODO [CORE-1524]
+	        addContextListener: async (contextType, handler) => {
+	            checkIfClientDisconnected();
+	            let handlerInUse = handler;
+	            let contextTypeInUse = contextType;
+	            if (typeof contextType === 'function') {
+	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                handlerInUse = contextType;
+	                contextTypeInUse = null;
+	            }
+	            const listener = privateChannelClient.addContextListener(contextTypeInUse, handlerInUse);
+	            return listener;
+	        },
+	        onAddContextListener: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onAddContextListener(handler);
+	        },
+	        disconnect: async () => {
+	            checkIfClientDisconnected();
+	            clientDisconnected = true;
+	            return privateChannelClient.disconnect();
+	        },
+	        onDisconnect: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onDisconnect(handler);
+	        },
+	        onUnsubscribe: (handler) => {
+	            checkIfClientDisconnected();
+	            return privateChannelClient.onUnsubscribe(handler);
+	        }
+	    };
+	};
+	exports.buildPrivateChannelObject = buildPrivateChannelObject;
+	const buildAppChannelObject = (sessionContextGroup) => {
+	    return {
+	        id: sessionContextGroup.id,
+	        type: 'app',
+	        broadcast: sessionContextGroup.setContext,
+	        getCurrentContext: async (contextType) => {
+	            const context = await sessionContextGroup.getCurrentContext(contextType);
+	            return context === undefined ? null : context;
+	        },
+	        // @ts-expect-error TODO [CORE-1524]
+	        addContextListener: (contextType, handler) => {
+	            let realHandler;
+	            let realType;
+	            if (typeof contextType === 'function') {
+	                console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                realHandler = contextType;
+	            }
+	            else {
+	                realHandler = handler;
+	                if (typeof contextType === 'string') {
+	                    realType = contextType;
+	                }
+	            }
+	            const listener = (async () => {
+	                let first = true;
+	                const currentContext = await sessionContextGroup.getCurrentContext(realType);
+	                const wrappedHandler = (context, contextMetadata) => {
+	                    if (first) {
+	                        first = false;
+	                        if ((0, lodash_1.isEqual)(currentContext, context)) {
+	                            return;
+	                        }
+	                    }
+	                    // eslint-disable-next-line consistent-return
+	                    return realHandler(context, contextMetadata);
+	                };
+	                return sessionContextGroup.addContextHandler(wrappedHandler, realType);
+	            })();
+	            return {
+	                ...listener,
+	                unsubscribe: () => listener.then((l) => l.unsubscribe())
+	            };
+	        }
+	    };
+	};
+	exports.buildAppChannelObject = buildAppChannelObject;
+	const connectPrivateChannel = async (channelId) => {
+	    try {
+	        const channelClient = await fin.InterApplicationBus.Channel.connect(channelId);
+	        const privateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+	        return (0, exports.buildPrivateChannelObject)(privateChannelClient);
+	    }
+	    catch (error) {
+	        throw new Error(`Private Channel with id: ${channelId} doesn't exist`);
+	    }
+	};
+	exports.connectPrivateChannel = connectPrivateChannel;
+	const isContext = (context) => {
+	    if (context && typeof context === 'object' && 'type' in context) {
+	        const { type } = context;
+	        return typeof type === 'string';
+	    }
+	    return false;
+	};
+	exports.isContext = isContext;
+	const isChannel = (channel) => {
+	    if (channel && typeof channel === 'object' && 'type' in channel && 'id' in channel) {
+	        const { type, id } = channel;
+	        return typeof type === 'string' && typeof id === 'string' && (type === 'app' || type === 'private');
+	    }
+	    return false;
+	};
+	exports.isChannel = isChannel;
+	const getIntentResolution = async (interopModule, context, app, intent) => {
+	    // Generate an ID to make a session context group with. We will pass that ID to the Broker.
+	    // The broker will then setContext on that session context group later with our Intent Result,
+	    const guid = (0, utils_1.generateId)(); // TODO make this undefined in web
+	    // Promise we'll use in getResult
+	    const getResultPromise = new Promise((resolve, reject) => {
+	        fin.InterApplicationBus.subscribe({ uuid: '*' }, guid, (intentResult) => {
+	            resolve(intentResult);
+	        }).catch(() => reject(new Error('getResult is not supported in this environment')));
+	    });
+	    // Adding the intentResolutionResultId to the intentObj. Because fireIntent only accepts a single arg, we have to slap it in here.
+	    const metadata = app ? { target: app, intentResolutionResultId: guid } : { intentResolutionResultId: guid };
+	    const intentObj = intent ? { name: intent, context, metadata } : { ...context, metadata };
+	    // Set up the getResult call.
+	    const getResult = async () => {
+	        let intentResult = await getResultPromise;
+	        if (!intentResult || typeof intentResult !== 'object') {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        const { error } = intentResult;
+	        if (error) {
+	            throw new Error(ResultError.IntentHandlerRejected);
+	        }
+	        if ((0, exports.isChannel)(intentResult)) {
+	            const { id, type } = intentResult;
+	            switch (type) {
+	                case 'private': {
+	                    intentResult = await (0, exports.connectPrivateChannel)(id);
+	                    break;
+	                }
+	                case 'app': {
+	                    const sessionContextGroup = await interopModule.joinSessionContextGroup(id);
+	                    intentResult = (0, exports.buildAppChannelObject)(sessionContextGroup);
+	                    break;
+	                }
+	            }
+	        }
+	        else if (!(0, exports.isContext)(intentResult)) {
+	            throw new Error(ResultError.NoResultReturned);
+	        }
+	        return intentResult;
+	    };
+	    // Finally fire the intent.
+	    const intentResolutionInfoFromBroker = intent
+	        ? await interopModule.fireIntent(intentObj)
+	        : await interopModule.fireIntentForContext(intentObj);
+	    if (typeof intentResolutionInfoFromBroker !== 'object') {
+	        return {
+	            source: {
+	                appId: '',
+	                instanceId: ''
+	            },
+	            intent: '',
+	            version: '2.0',
+	            getResult
+	        };
+	    }
+	    return { ...intentResolutionInfoFromBroker, getResult };
+	};
+	exports.getIntentResolution = getIntentResolution; 
+} (utils$2));
+
+var hasRequiredFdc3Common;
+
+function requireFdc3Common () {
+	if (hasRequiredFdc3Common) return fdc3Common;
+	hasRequiredFdc3Common = 1;
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+	    if (kind === "m") throw new TypeError("Private method is not writable");
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+	};
+	var _FDC3ModuleBase_producer;
+	Object.defineProperty(fdc3Common, "__esModule", { value: true });
+	fdc3Common.FDC3ModuleBase = void 0;
+	const utils_1 = utils$2;
+	const utils_2 = utils$3;
+	const InteropClient_1 = requireInteropClient();
+	const lodash_1 = require$$3;
+	class FDC3ModuleBase {
+	    get client() {
+	        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
+	    }
+	    get fin() {
+	        return this.wire.getFin();
+	    }
+	    // eslint-disable-next-line no-useless-constructor
+	    constructor(producer, wire) {
+	        this.wire = wire;
+	        _FDC3ModuleBase_producer.set(this, void 0);
+	        __classPrivateFieldSet(this, _FDC3ModuleBase_producer, producer, "f");
+	    }
+	    /**
+	     * Broadcasts a context for the channel of the current entity.
+	     * @param context - New context to set.
+	     *
+	     * @tutorial fdc3.broadcast
+	     * @static
+	     */
+	    async broadcast(context) {
+	        this.wire.sendAction('fdc3-broadcast').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.client.setContext(context);
+	    }
+	    /**
+	     * Launches an app with target information, which can either be a string or an AppMetadata object.
+	     * @param app
+	     * @param context
+	     *
+	     * @tutorial fdc3.open
+	     */
+	    async _open(app, context) {
+	        this.wire.sendAction('fdc3-open').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3Open', { app, context });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_2.BROKER_ERRORS.fdc3Open ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        this.wire.sendAction('fdc3-get-or-create-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const systemChannels = await this.getSystemChannels();
+	        const userChannel = systemChannels.find((channel) => channel.id === channelId);
+	        if (userChannel) {
+	            return { ...userChannel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+	        }
+	        try {
+	            const sessionContextGroup = await this.client.joinSessionContextGroup(channelId);
+	            return (0, utils_1.buildAppChannelObject)(sessionContextGroup);
+	        }
+	        catch (error) {
+	            console.error(error.message);
+	            throw new Error(utils_1.ChannelError.CreationFailed);
+	        }
+	    }
+	    /**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     *
+	     * @tutorial fdc3.getSystemChannels
+	     * @static
+	     */
+	    async getSystemChannels() {
+	        this.wire.sendAction('fdc3-get-system-channels').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const channels = await this.client.getContextGroups();
+	        // fdc3 implementation of getSystemChannels returns on array of channels, have to decorate over
+	        // this so people know that these APIs are not supported
+	        return channels.map((channel) => {
+	            return { ...channel, type: 'system', ...(0, utils_1.getUnsupportedChannelApis)() };
+	        });
+	    }
+	    /**
+	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+	     * If no target is specified, it adds the sender to the context group.
+	     * Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implementations, so this point is more-or-less moot.
+	     * @param channelId - Id of the context group.
+	     *
+	     * @tutorial fdc3.joinChannel
+	     * @static
+	     */
+	    async joinChannel(channelId) {
+	        this.wire.sendAction('fdc3-join-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.joinContextGroup(channelId);
+	        }
+	        catch (error) {
+	            if (error.message === utils_2.BROKER_ERRORS.joinSessionContextGroupWithJoinContextGroup) {
+	                console.error('The Channel you have tried to join is an App Channel. Custom Channels can only be defined by the Interop Broker through code or manifest configuration. Please use getOrCreateChannel.');
+	            }
+	            else {
+	                console.error(error.message);
+	            }
+	            if (error.message.startsWith('Attempting to join a context group that does not exist')) {
+	                throw new Error(utils_1.ChannelError.NoChannelFound);
+	            }
+	            throw new Error(utils_1.ChannelError.AccessDenied);
+	        }
+	    }
+	    /**
+	     * Returns the Channel that the entity is subscribed to. Returns null if not joined to a channel.
+	     *
+	     * @tutorial fdc3.getCurrentChannel
+	     */
+	    async getCurrentChannel() {
+	        this.wire.sendAction('fdc3-get-current-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const currentContextGroupInfo = await this.getCurrentContextGroupInfo();
+	        if (!currentContextGroupInfo) {
+	            return null;
+	        }
+	        return this.buildChannelObject(currentContextGroupInfo);
+	    }
+	    /**
+	     * Removes the specified target from a context group.
+	     * If no target is specified, it removes the sender from their context group.
+	     *
+	     * @tutorial fdc3.leaveCurrentChannel
+	     * @static
+	     */
+	    async leaveCurrentChannel() {
+	        this.wire.sendAction('fdc3-leave-current-channel').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        return this.client.removeFromContextGroup();
+	    }
+	    // utils
+	    // eslint-disable-next-line class-methods-use-this
+	    async getCurrentContextGroupInfo() {
+	        const contextGroups = await this.client.getContextGroups();
+	        const clientsInCtxGroupsPromise = contextGroups.map(async (ctxGroup) => {
+	            return this.client.getAllClientsInContextGroup(ctxGroup.id);
+	        });
+	        const clientsInCtxGroups = await Promise.all(clientsInCtxGroupsPromise);
+	        const clientIdx = clientsInCtxGroups.findIndex((clientIdentityArr) => {
+	            return clientIdentityArr.some((clientIdentity) => {
+	                const { uuid, name } = clientIdentity;
+	                return this.wire.me.uuid === uuid && this.wire.me.name === name;
+	            });
+	        });
+	        return contextGroups[clientIdx];
+	    }
+	    async buildChannelObject(currentContextGroupInfo) {
+	        // @ts-expect-error
+	        return {
+	            ...currentContextGroupInfo,
+	            type: 'system',
+	            addContextListener: (...[contextType, handler]) => {
+	                let realHandler;
+	                let realType;
+	                if (typeof contextType === 'function') {
+	                    console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	                    realHandler = contextType;
+	                }
+	                else {
+	                    realHandler = handler;
+	                    if (typeof contextType === 'string') {
+	                        realType = contextType;
+	                    }
+	                }
+	                const listener = (async () => {
+	                    let first = true;
+	                    const currentContext = await this.client.getCurrentContext(realType);
+	                    const wrappedHandler = (context, contextMetadata) => {
+	                        if (first) {
+	                            first = false;
+	                            if ((0, lodash_1.isEqual)(currentContext, context)) {
+	                                return;
+	                            }
+	                        }
+	                        // eslint-disable-next-line consistent-return
+	                        return realHandler(context, contextMetadata);
+	                    };
+	                    return this.client.addContextHandler(wrappedHandler, realType);
+	                })();
+	                // @ts-expect-error TODO [CORE-1524]
+	                return {
+	                    ...listener,
+	                    unsubscribe: () => listener.then((l) => l.unsubscribe())
+	                };
+	            },
+	            broadcast: this.broadcast.bind(this),
+	            // @ts-expect-error Typescript fails to infer the returntype is a Promise
+	            getCurrentContext: async (contextType) => {
+	                const context = await this.client.getCurrentContext(contextType);
+	                // @ts-expect-error Typescript fails to infer the returntype is a Promise
+	                return context === undefined ? null : context;
+	            }
+	        };
+	    }
+	}
+	fdc3Common.FDC3ModuleBase = FDC3ModuleBase;
+	_FDC3ModuleBase_producer = new WeakMap();
+	return fdc3Common;
+}
+
+var hasRequiredFdc31_2;
+
+function requireFdc31_2 () {
+	if (hasRequiredFdc31_2) return fdc31_2;
+	hasRequiredFdc31_2 = 1;
+	Object.defineProperty(fdc31_2, "__esModule", { value: true });
+	fdc31_2.Fdc3Module = void 0;
+	const utils_1 = utils$3;
+	const fdc3_common_1 = requireFdc3Common();
+	/**
+	 * @version 1.2
+	 * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+	 * while using our Interop API under the hood. In order to use this set of APIs
+	 * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+	 * our {@link https://developers.openfin.co/of-docs/docs/enable-color-linking Interop API}.
+	 *
+	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+	 * property to its options:
+	 *
+	 * ```js
+	 * {
+	 *     autoShow: false,
+	 *     saveWindowState: true,
+	 *     url: 'https://openfin.co',
+	 *     fdc3InteropApi: '1.2'
+	 * }
+	 * ```
+	 *
+	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+	 *
+	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+	 *
+	 * ```js
+	 * function fdc3Action() {
+	 *     // Make some fdc3 API calls here
+	 * }
+	 *
+	 * if (window.fdc3) {
+	 *    fdc3Action();
+	 * } else {
+	 *    window.addEventListener('fdc3Ready', fdc3Action);
+	 * }
+	 * ```
+	 */
+	class Fdc3Module extends fdc3_common_1.FDC3ModuleBase {
+	    async open(app, context) {
+	        // eslint-disable-next-line no-underscore-dangle
+	        await super._open(app, context);
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+	     * @param contextType - The type of context you wish to handle.
+	     * @param handler - Handler for incoming context.
+	     *
+	     * @tutorial fdc3.addContextListener
+	     * @static
+	     */
+	    // @ts-expect-error TODO [CORE-1524]
+	    addContextListener(contextType, handler) {
+	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        let listener;
+	        if (typeof contextType === 'function') {
+	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	            listener = this.client.addContextHandler(contextType);
+	        }
+	        else {
+	            listener = this.client.addContextHandler(handler, contextType === null ? undefined : contextType);
+	        }
+	        return {
+	            ...listener,
+	            unsubscribe: () => listener.then((l) => l.unsubscribe())
+	        };
+	    }
+	    /**
+	     * Adds a listener for incoming Intents.
+	     * @param intent - Name of the Intent
+	     * @param handler - Handler for incoming Intent
+	     *
+	     * @tutorial fdc3.addIntentListener
+	     * @static
+	     */
+	    addIntentListener(intent, handler) {
+	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const contextHandler = (raisedIntent) => {
+	            const { context, metadata: intentMetadata } = raisedIntent;
+	            const { metadata } = context;
+	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+	            if (intentResolutionResultId) {
+	                this.fin.InterApplicationBus.publish(intentResolutionResultId, null).catch(() => null);
+	            }
+	            handler(raisedIntent.context);
+	        };
+	        const listener = this.client.registerIntentHandler(contextHandler, intent, {
+	            fdc3Version: '1.2'
+	        });
+	        return {
+	            ...listener,
+	            unsubscribe: () => listener.then((l) => l.unsubscribe())
+	        };
+	    }
+	    /**
+	     * Raises a specific intent.
+	     * @param intent Name of the Intent.
+	     * @param context Context associated with the Intent.
+	     * @param  app App that will resolve the Intent. This is added as metadata to the Intent. Can be accessed by the app provider in {@link InteropBroker#handleFiredIntent InteropBroker.handleFiredIntent}.
+	     *
+	     * @tutorial fdc3.raiseIntent
+	     * @static
+	     */
+	    async raiseIntent(intent, context, app) {
+	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const intentObj = app
+	            ? { name: intent, context, metadata: { target: app } }
+	            : { name: intent, context };
+	        try {
+	            return await this.client.fireIntent(intentObj);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find out more information about a particular intent by passing its name, and optionally its context.
+	     * @param intent Name of the Intent
+	     * @param context
+	     *
+	     * @tutorial fdc3.findIntent
+	     */
+	    async findIntent(intent, context) {
+	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntent({ name: intent, context });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find all the available intents for a particular context.
+	     * @param context
+	     *
+	     * @tutorial fdc3.findIntentsByContext
+	     */
+	    async findIntentsByContext(context) {
+	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntentsByContext(context);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Finds and raises an intent against a target app based purely on context data.
+	     * @param context
+	     * @param app
+	     *
+	     * @tutorial fdc3.raiseIntentForContext
+	     */
+	    async raiseIntentForContext(context, app) {
+	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.fireIntentForContext({ ...context, metadata: { target: app } });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntentForContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        return super.getOrCreateChannel(channelId);
+	    }
+	    /**
+	     * Returns metadata relating to the FDC3 object and its provider, including the supported version of the FDC3 specification and the name of the provider of the implementation.
+	     *
+	     * @tutorial fdc3.getInfo
+	     */
+	    getInfo() {
+	        this.wire.sendAction('fdc3-get-info').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        // @ts-expect-error
+	        const { uuid, fdc3InteropApi } = fin.__internal_.initialOptions;
+	        // @ts-expect-error
+	        const runtimeVersion = fin.desktop.getVersion();
+	        return {
+	            fdc3Version: fdc3InteropApi,
+	            provider: `openfin-${uuid}`,
+	            providerVersion: runtimeVersion
+	        };
+	    }
+	}
+	fdc31_2.Fdc3Module = Fdc3Module;
+	return fdc31_2;
+}
+
+var fdc32_0 = {};
+
+var hasRequiredFdc32_0;
+
+function requireFdc32_0 () {
+	if (hasRequiredFdc32_0) return fdc32_0;
+	hasRequiredFdc32_0 = 1;
+	Object.defineProperty(fdc32_0, "__esModule", { value: true });
+	fdc32_0.Fdc3Module2 = void 0;
+	const fdc3_common_1 = requireFdc3Common();
+	const utils_1 = utils$3;
+	const InteropClient_1 = requireInteropClient();
+	const utils_2 = utils$2;
+	const PrivateChannelClient_1 = PrivateChannelClient$1;
+	/**
+	 * @version 2.0
+	 * The FDC3 Client Library provides a set APIs to be used for FDC3 compliance,
+	 * while using our Interop API under the hood. In order to use this set of APIs
+	 * you will need to set up your own {@link InteropBroker InteropBroker} or use a Platform application, which does the setup for you. Refer to our documentation on
+	 * our {@link https://developers.openfin.co/of-docs/docs/enable-context-sharing Interop API}.
+	 *
+	 * To enable the FDC3 APIs in a {@link Window Window} or {@link View View}, add the fdc3InteropApi
+	 * property to its options:
+	 *
+	 * ```js
+	 * {
+	 *     autoShow: false,
+	 *     saveWindowState: true,
+	 *     url: 'https://openfin.co',
+	 *     fdc3InteropApi: '2.0'
+	 * }
+	 * ```
+	 *
+	 * If using a {@link Platform Platform } application, you can set this property in defaultWindowOptions and defaultViewOptions.
+	 *
+	 * In order to ensure that the FDC3 Api is ready before use, you can use the 'fdc3Ready' event fired on the DOM Window object:
+	 *
+	 * ```js
+	 * function fdc3Action() {
+	 *     // Make some fdc3 API calls here
+	 * }
+	 *
+	 * if (window.fdc3) {
+	 *    fdc3Action();
+	 * } else {
+	 *    window.addEventListener('fdc3Ready', fdc3Action);
+	 * }
+	 * ```
+	 */
+	class Fdc3Module2 extends fdc3_common_1.FDC3ModuleBase {
+	    /**
+	     * Launches an app, specified via an AppIdentifier object.
+	     * @param app
+	     * @param context
+	     *
+	     * @tutorial fdc3.open
+	     */
+	    async open(app, context) {
+	        if (typeof app === 'string') {
+	            console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	        }
+	        // eslint-disable-next-line no-underscore-dangle
+	        return super._open(app, context);
+	    }
+	    /**
+	     * Find all the available instances for a particular application.
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.findInstances
+	     */
+	    async findInstances(app) {
+	        this.wire.sendAction('fdc3-find-instances').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3FindInstances', app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3FindInstances ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Retrieves the AppMetadata for an AppIdentifier, which provides additional metadata (such as icons, a title and description) from the App Directory record for the application, that may be used for display purposes.
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.getAppMetadata
+	     */
+	    async getAppMetadata(app) {
+	        this.wire.sendAction('fdc3-get-app-metadata').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3GetAppMetadata', app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fdc3GetAppMetadata ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler, it will receive all of its declared contexts. If you wish to listen for all incoming contexts, pass `null` for the contextType argument.
+	     * @param contextType
+	     * @param handler
+	     *
+	     * @tutorial fdc3.addContextListener
+	     */
+	    // @ts-expect-error TODO [CORE-1524]
+	    async addContextListener(contextType, handler) {
+	        this.wire.sendAction('fdc3-add-context-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        // The FDC3 ContextHandler only expects the context and optional ContextMetadata, so we wrap the handler
+	        // here so it only gets passed these parameters
+	        const getWrappedHandler = (handlerToWrap) => {
+	            return (context) => {
+	                const { contextMetadata, ...rest } = context;
+	                const args = contextMetadata ? [{ ...rest }, contextMetadata] : [context, null];
+	                handlerToWrap(...args);
+	            };
+	        };
+	        let actualHandler = handler;
+	        let wrappedHandler = getWrappedHandler(actualHandler);
+	        if (typeof contextType === 'function') {
+	            console.warn('addContextListener(handler) has been deprecated. Please use addContextListener(null, handler)');
+	            actualHandler = contextType;
+	            wrappedHandler = getWrappedHandler(actualHandler);
+	            return this.client.addContextHandler(wrappedHandler);
+	        }
+	        return this.client.addContextHandler(wrappedHandler, contextType === null ? undefined : contextType);
+	    }
+	    /**
+	     * Find out more information about a particular intent by passing its name, and optionally its context and resultType.
+	     * @param intent Name of the Intent
+	     * @param context Context
+	     * @param resultType The type of result returned for any intent specified during resolution.
+	     *
+	     * @tutorial fdc3.findIntent
+	     */
+	    async findIntent(intent, context, resultType) {
+	        this.wire.sendAction('fdc3-find-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            return await this.client.getInfoForIntent({ name: intent, context, metadata: { resultType } });
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Find all the available intents for a particular context.
+	     * @param context
+	     * @param resultType The type of result returned for any intent specified during resolution.
+	     *
+	     * @tutorial fdc3v2.findIntentsByContext
+	     */
+	    async findIntentsByContext(context, resultType) {
+	        this.wire.sendAction('fdc3-find-intents-by-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        const payload = resultType ? { context, metadata: { resultType } } : context;
+	        try {
+	            return await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2FindIntentsByContext', payload);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.getInfoForIntentsByContext ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Raises a specific intent for resolution against apps registered with the desktop agent.
+	     * @param intent Name of the Intent
+	     * @param context Context associated with the Intent
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.raiseIntent
+	     */
+	    async raiseIntent(intent, context, app) {
+	        this.wire.sendAction('fdc3-raise-intent').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            if (typeof app === 'string') {
+	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	            }
+	            return (0, utils_2.getIntentResolution)(this.client, context, app, intent);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Finds and raises an intent against apps registered with the desktop agent based purely on the type of the context data.
+	     * @param context Context associated with the Intent
+	     * @param app
+	     *
+	     * @tutorial fdc3v2.raiseIntentForContext
+	     */
+	    async raiseIntentForContext(context, app) {
+	        // TODO: We have to do the same thing we do for raiseIntent here as well.
+	        this.wire.sendAction('fdc3-raise-intent-for-context').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        try {
+	            if (typeof app === 'string') {
+	                console.warn('Passing a string as the app parameter is deprecated, please use an AppIdentifier ({ appId: string; instanceId?: string }).');
+	            }
+	            return (0, utils_2.getIntentResolution)(this.client, context, app);
+	        }
+	        catch (error) {
+	            const errorToThrow = error.message === utils_1.BROKER_ERRORS.fireIntent ? 'ResolverUnavailable' : error.message;
+	            throw new Error(errorToThrow);
+	        }
+	    }
+	    /**
+	     * Adds a listener for incoming intents.
+	     * @param intent  Name of the Intent
+	     * @param handler A callback that handles a context event and may return a promise of a Context or Channel object to be returned to the application that raised the intent.
+	     *
+	     * @tutorial fdc3.addIntentListener
+	     */
+	    async addIntentListener(intent, handler) {
+	        this.wire.sendAction('fdc3-add-intent-listener').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
+	        if (typeof intent !== 'string') {
+	            throw new Error('First argument must be an Intent name');
+	        }
+	        // The FDC3 Intenter handler only expects the context and contextMetadata to be passed to the handler,
+	        // so we wrap it here and only pass those paramaters.
+	        const contextHandler = async (raisedIntent) => {
+	            let intentResult;
+	            let intentResultToSend;
+	            const { context, metadata: intentMetadata } = raisedIntent;
+	            const { contextMetadata, metadata, ...rest } = context;
+	            const intentResolutionResultId = intentMetadata?.intentResolutionResultId || metadata?.intentResolutionResultId;
+	            try {
+	                const newContext = metadata ? { metadata, ...rest } : { ...rest };
+	                intentResult = await handler(newContext, contextMetadata);
+	                intentResultToSend = intentResult;
+	            }
+	            catch (error) {
+	                intentResult = error;
+	                intentResultToSend = { error: true };
+	            }
+	            if (intentResolutionResultId) {
+	                this.fin.InterApplicationBus.publish(intentResolutionResultId, intentResultToSend).catch(() => null);
+	            }
+	            if (intentResult instanceof Error) {
+	                throw new Error(intentResult.message);
+	            }
+	            return intentResult;
+	        };
+	        return this.client.registerIntentHandler(contextHandler, intent, { fdc3Version: '2.0' });
+	    }
+	    /**
+	     * Returns a Channel object for the specified channel, creating it as an App Channel if it does not exist.
+	     * @param channelId
+	     *
+	     * @tutorial fdc3.getOrCreateChannel
+	     */
+	    async getOrCreateChannel(channelId) {
+	        return super.getOrCreateChannel(channelId);
+	    }
+	    /**
+	     * Returns a Channel with an auto-generated identity that is intended for private communication between applications. Primarily used to create channels that will be returned to other applications via an IntentResolution for a raised intent.
+	     *
+	     * @tutorial fdc3v2.createPrivateChannel
+	     */
+	    async createPrivateChannel() {
+	        const channelId = (0, utils_1.generateId)();
+	        await InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'createPrivateChannelProvider', { channelId });
+	        const channelClient = await this.fin.InterApplicationBus.Channel.connect(channelId);
+	        const newPrivateChannelClient = new PrivateChannelClient_1.PrivateChannelClient(channelClient, channelId);
+	        return (0, utils_2.buildPrivateChannelObject)(newPrivateChannelClient);
+	    }
+	    /**
+	     * Retrieves a list of the User Channels available for the app to join.
+	     *
+	     * @tutorial fdc3v2.getUserChannels
+	     */
+	    async getUserChannels() {
+	        const channels = await this.client.getContextGroups();
+	        // fdc3 implementation of getUserChannels returns on array of channels, have to decorate over
+	        // this so people know that these APIs are not supported
+	        return channels.map((channel) => {
+	            // @ts-expect-error TODO [CORE-1524]
+	            return { ...channel, type: 'user', ...(0, utils_2.getUnsupportedChannelApis)('User') };
+	        });
+	    }
+	    /**
+	     * Retrieves a list of the User Channels available for the app to join.
+	     *
+	     * @deprecated Please use {@link fdc3.getUserChannels fdc3.getUserChannels} instead
+	     * @tutorial fdc3.getSystemChannels
+	     */
+	    async getSystemChannels() {
+	        console.warn('This API has been deprecated. Please use fdc3.getUserChannels instead.');
+	        return super.getSystemChannels();
+	    }
+	    /**
+	     * Join an app to a specified User channel.
+	     * @param channelId Channel name
+	     *
+	     * @tutorial fdc3v2.joinUserChannel
+	     */
+	    async joinUserChannel(channelId) {
+	        return super.joinChannel(channelId);
+	    }
+	    /**
+	     * Join an app to a specified User channel.
+	     * @param channelId Channel name
+	     * @deprecated Please use {@link fdc3.joinUserChannel fdc3.joinUserChannel} instead
+	     *
+	     * @tutorial fdc3.joinChannel
+	     */
+	    async joinChannel(channelId) {
+	        console.warn('This API has been deprecated. Please use fdc3.joinUserChannel instead.');
+	        return super.joinChannel(channelId);
+	    }
+	    /**
+	     * Returns the Channel object for the current User channel membership
+	     *
+	     * @tutorial fdc3.getCurrentChannel
+	     */
+	    async getCurrentChannel() {
+	        const currentChannel = await super.getCurrentChannel();
+	        if (!currentChannel) {
+	            return null;
+	        }
+	        return {
+	            ...currentChannel,
+	            type: 'user',
+	            broadcast: this.broadcast.bind(this)
+	        };
+	    }
+	    /**
+	     * Retrieves information about the FDC3 implementation, including the supported version of the FDC3 specification, the name of the provider of the implementation, its own version number, details of whether optional API features are implemented and the metadata of the calling application according to the desktop agent.
+	     * fdc3HandleGetInfo must be overridden in the InteropBroker so that the ImplementationMetadata will have the appMetadata info.
+	     *
+	     * @tutorial fdc3v2.getInfo
+	     */
+	    async getInfo() {
+	        return InteropClient_1.InteropClient.ferryFdc3Call(this.client, 'fdc3v2GetInfo', { fdc3Version: '2.0' });
+	    }
+	}
+	fdc32_0.Fdc3Module2 = Fdc3Module2;
+	return fdc32_0;
+}
+
+var hasRequiredInteropClient;
+
+function requireInteropClient () {
+	if (hasRequiredInteropClient) return InteropClient;
+	hasRequiredInteropClient = 1;
+	var __classPrivateFieldSet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+	    if (kind === "m") throw new TypeError("Private method is not writable");
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+	    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+	};
+	var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+	    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+	    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+	    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+	};
+	var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
+	Object.defineProperty(InteropClient, "__esModule", { value: true });
+	InteropClient.InteropClient = void 0;
+	const base_1 = base;
+	const SessionContextGroupClient_1 = SessionContextGroupClient$1;
+	const fdc3_1_2_1 = requireFdc31_2();
+	const fdc3_2_0_1 = requireFdc32_0();
+	const utils_1 = utils$3;
+	/**
+	 * The Interop Client API is broken up into two groups:
+	 *
+	 * **Content Facing APIs** - For Application Developers putting Views into a Platform Window, who care about Context. These are APIs that send out and receive the Context data that flows between applications. Think of this as the Water in the Interop Pipes.
+	 *
+	 * **Context Grouping APIs** - For Platform Developers, to add and remove Views to and from Context Groups. These APIs are utilized under-the-hood in Platforms, so they don't need to be used to participate in Interop. These are the APIs that decide which entities the context data flows between. Think of these as the valves or pipes that control the flow of Context Data for Interop.
+	 *
+	 * ---
+	 *
+	 * All APIs are available at the `fin.me.interop` namespace.
+	 *
+	 * ---
+	 *
+	 * **You only need 2 things to participate in Interop Context Grouping:**
+	 * * A Context Handler for incoming context: {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+	 * * Call setContext on your context group when you want to share context with other group members: {@link InteropClient#setContext setContext(context)}
+	 *
+	 * ---
+	 *
+	 * ##### Constructor
+	 * Returned by {@link Interop.connectSync Interop.connectSync}.
+	 *
+	 * ---
+	 *
+	 * ##### Interop methods intended for Views
+	 *
+	 *
+	 * **Context Groups API**
+	 *  * {@link InteropClient#addContextHandler addContextHandler(handler, contextType?)}
+	 *  * {@link InteropClient#setContext setContext(context)}
+	 *  * {@link InteropClient#getCurrentContext getCurrentContext(contextType?)}
+	 *  * {@link InteropClient#joinSessionContextGroup joinSessionContextGroup(sessionContextGroupId)}
+	 *
+	 *
+	 * **Intents API**
+	 *  * {@link InteropClient#fireIntent fireIntent(intent)}
+	 *  * {@link InteropClient#registerIntentHandler registerIntentHandler(intentHandler, intentName)}
+	 *  * {@link InteropClient#getInfoForIntent getInfoForIntent(infoForIntentOptions)}
+	 *  * {@link InteropClient#getInfoForIntentsByContext getInfoForIntentsByContext(context)}
+	 *  * {@link InteropClient#fireIntentForContext fireIntentForContext(contextForIntent)}
+	 *
+	 * ##### Interop methods intended for Windows
+	 *  * {@link InteropClient#getContextGroups getContextGroups()}
+	 *  * {@link InteropClient#joinContextGroup joinContextGroup(contextGroupId, target?)}
+	 *  * {@link InteropClient#removeFromContextGroup removeFromContextGroup(target?)}
+	 *  * {@link InteropClient#getInfoForContextGroup getInfoForContextGroup(contextGroupId)}
+	 *  * {@link InteropClient#getAllClientsInContextGroup getAllClientsInContextGroup(contextGroupId)}
+	 *
+	 */
+	let InteropClient$1 = class InteropClient extends base_1.Base {
+	    /**
+	     * @internal
+	     */
+	    constructor(wire, clientPromise) {
+	        super(wire);
+	        _InteropClient_clientPromise.set(this, void 0);
+	        _InteropClient_sessionContextGroups.set(this, void 0);
+	        __classPrivateFieldSet(this, _InteropClient_sessionContextGroups, new Map(), "f");
+	        __classPrivateFieldSet(this, _InteropClient_clientPromise, clientPromise, "f");
+	    }
+	    /*
+	    Client APIs
+	    */
+	    /**
+	     * Sets a context for the context group of the current entity.
+	     *
+	     * @remarks The entity must be part of a context group in order set a context.
+	     *
+	     * @param context - New context to set.
+	     *
+	     * @example
+	     * ```js
+	     * setInstrumentContext = async (ticker) => {
+	     *     fin.me.interop.setContext({type: 'instrument', id: {ticker}})
+	     * }
+	     *
+	     * // The user clicks an instrument of interest. We want to set that Instrument context so that the rest of our workflow updates with information for that instrument
+	     * instrumentElement.on('click', (evt) => {
+	     *     setInstrumentContext(evt.ticker)
+	     * })
+	     * ```
+	     */
+	    async setContext(context) {
+	        this.wire.sendAction('interop-client-set-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('setContext', { context });
+	    }
+	    /**
+	     * Add a context handler for incoming context. If an entity is part of a context group, and then sets its context handler,
+	     * it will receive all of its declared contexts.
+	     *
+	     * @param handler - Handler for incoming context.
+	     * @param contextType - The type of context you wish to handle.
+	     *
+	     * @example
+	     * ```js
+	     * function handleIncomingContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     switch (type) {
+	     *         case 'instrument':
+	     *             handleInstrumentContext(contextInfo);
+	     *             break;
+	     *         case 'country':
+	     *             handleCountryContext(contextInfo);
+	     *             break;
+	     *
+	     *         default:
+	     *             break;
+	     *     }
+	     * }
+	     *
+	     *
+	     * function handleInstrumentContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for instrument', contextInfo)
+	     * }
+	     *
+	     * function handleCountryContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for country', contextInfo)
+	     * }
+	     *
+	     * fin.me.interop.addContextHandler(handleIncomingContext);
+	     * ```
+	     *
+	     *
+	     * We are also testing the ability to add a context handler for specific contexts. If you would like to use
+	     * this, please make sure you add your context handlers at the top level of your application, on a page that
+	     * does not navigate/reload/re-render, to avoid memory leaks.  This feature is experimental:
+	     *
+	     * ```js
+	     * function handleInstrumentContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for instrument', contextInfo)
+	     * }
+	     *
+	     * function handleCountryContext(contextInfo) {
+	     *     const { type, id } = contextInfo;
+	     *     console.log('contextInfo for country', contextInfo)
+	     * }
+	     *
+	     *
+	     * fin.me.interop.addContextHandler(handleInstrumentContext, 'instrument')
+	     * fin.me.interop.addContextHandler(handleCountryContext, 'country')
+	     * ```
+	     */
+	    async addContextHandler(handler, contextType) {
+	        this.wire.sendAction('interop-client-add-context-handler').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        if (typeof handler !== 'function') {
+	            throw new Error("Non-function argument passed to the first parameter 'handler'. Be aware that the argument order does not match the FDC3 standard.");
+	        }
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        let handlerId;
+	        if (contextType) {
+	            handlerId = `invokeContextHandler-${contextType}-${(0, utils_1.generateId)()}`;
+	            console.warn(`Warning: By providing a contextType (${contextType}), you are using the experimental addContextHandler. To avoid issues, make sure you are adding your context handlers at the top level in your application.`);
+	        }
+	        else {
+	            handlerId = 'invokeContextHandler';
+	        }
+	        const wrappedHandler = (0, utils_1.wrapContextHandler)(handler, handlerId);
+	        client.register(handlerId, wrappedHandler);
+	        await client.dispatch('contextHandlerRegistered', { handlerId, contextType });
+	        return {
+	            unsubscribe: async () => {
+	                client.remove(handlerId);
+	                await client.dispatch('removeContextHandler', { handlerId });
+	            }
+	        };
+	    }
+	    /*
+	    Platform Window APIs
+	    */
+	    /**
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     * Used by Platform Windows.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getContextGroups()
+	     *         .then(contextGroups => {
+	     *             contextGroups.forEach(contextGroup => {
+	     *                 console.log(contextGroup.displayMetadata.name)
+	     *                 console.log(contextGroup.displayMetadata.color)
+	     *             })
+	     *         })
+	     * ```
+	     */
+	    async getContextGroups() {
+	        this.wire.sendAction('interop-client-get-context-groups').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getContextGroups');
+	    }
+	    /**
+	     * Join all Interop Clients at the given identity to context group `contextGroupId`.
+	     * If no target is specified, it adds the sender to the context group.
+	     *
+	     * @remarks Because multiple Channel connections/Interop Clients can potentially exist at a `uuid`/`name` combo, we currently join all Channel connections/Interop Clients at the given identity to the context group.
+	     * If an `endpointId` is provided (which is unlikely, unless the call is coming from an external adapter), then we only join that single connection to the context group.
+	     * For all intents and purposes, there will only be 1 connection present in Platform and Browser implmentations, so this point is more-or-less moot.
+	     * Used by Platform Windows.
+	     *
+	     * @param contextGroupId - Id of the context group.
+	     * @param target - Identity of the entity you wish to join to a context group.
+	     *
+	     * @example
+	     * ```js
+	     * joinViewToContextGroup = async (contextGroupId, view) => {
+	     *     await fin.me.interop.joinContextGroup(contextGroupId, view);
+	     * }
+	     *
+	     * getLastFocusedView()
+	     *     .then(lastFocusedViewIdentity => {
+	     *         joinViewToContextGroup('red', lastFocusedViewIdentity)
+	     *     })
+	     * ```
+	     */
+	    async joinContextGroup(contextGroupId, target) {
+	        this.wire.sendAction('interop-client-join-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for joinContextGroup.');
+	        }
+	        return client.dispatch('joinContextGroup', { contextGroupId, target });
+	    }
+	    /**
+	     * Removes the specified target from a context group.
+	     * If no target is specified, it removes the sender from their context group.
+	     * Used by Platform Windows.
+	     *
+	     * @param target - Identity of the entity you wish to join to a context group.
+	     *
+	     * @example
+	     * ```js
+	     * removeViewFromContextGroup = async (view) => {
+	     *     await fin.me.interop.removeFromContextGroup(view);
+	     * }
+	     *
+	     * getLastFocusedView()
+	     *     .then(lastFocusedViewIdentity => {
+	     *         removeViewFromContextGroup(lastFocusedViewIdentity)
+	     *     })
+	     * ```
+	     */
+	    async removeFromContextGroup(target) {
+	        this.wire.sendAction('interop-client-remove-from-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('removeFromContextGroup', { target });
+	    }
+	    /**
+	     * Gets all clients for a context group.
+	     *
+	     * @remarks **This is primarily used for platform windows. Views within a platform should not have to use this API.**
+	     *
+	     * Returns the Interop-Broker-defined context groups available for an entity to join.
+	     * @param contextGroupId - The id of context group you wish to get clients for.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getAllClientsInContextGroup('red')
+	     *     .then(clientsInContextGroup => {
+	     *         console.log(clientsInContextGroup)
+	     *     })
+	     * ```
+	     */
+	    async getAllClientsInContextGroup(contextGroupId) {
+	        this.wire.sendAction('interop-client-get-all-clients-in-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
+	        }
+	        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
+	    }
+	    /**
+	     * Gets display info for a context group
+	     *
+	     * @remarks Used by Platform Windows.
+	     * @param contextGroupId - The id of context group you wish to get display info for.
+	     *
+	     * @example
+	     * ```js
+	     * fin.me.interop.getInfoForContextGroup('red')
+	     *     .then(contextGroupInfo => {
+	     *         console.log(contextGroupInfo.displayMetadata.name)
+	     *         console.log(contextGroupInfo.displayMetadata.color)
+	     *     })
+	     * ```
+	     */
+	    async getInfoForContextGroup(contextGroupId) {
+	        this.wire.sendAction('interop-client-get-info-for-context-group').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        if (!contextGroupId) {
+	            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
+	        }
+	        return client.dispatch('getInfoForContextGroup', { contextGroupId });
+	    }
+	    /**
+	     * Sends an intent to the Interop Broker to resolve.
+	     * @param intent - The combination of an action and a context that is passed to an application for resolution.
+	     *
+	     * @example
+	     * ```js
+	     * // View wants to fire an Intent after a user clicks on a ticker
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *     const intent = {
+	     *         name: 'ViewChart',
+	     *         context: {type: 'fdc3.instrument', id: { ticker }}
+	     *     }
+	     *
+	     *     fin.me.interop.fireIntent(intent);
+	     * })
+	     * ```
+	     */
+	    async fireIntent(intent) {
+	        this.wire.sendAction('interop-client-fire-intent').catch((e) => {
+	            // don't expose, this is only for api analytics purposes
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('fireIntent', intent);
+	    }
+	    /**
+	     * Adds an intent handler for incoming intents. The last intent sent of the name subscribed to will be received.
+	     * @param handler - Registered function meant to handle a specific intent type.
+	     * @param intentName - The name of an intent.
+	     *
+	     * @example
+	     * ```js
+	     * const intentHandler = (intent) => {
+	     *     const { context } = intent;
+	     *     myViewChartHandler(context);
+	     * };
+	     *
+	     * const subscription = await fin.me.interop.registerIntentHandler(intentHandler, 'ViewChart');
+	     *
+	     * function myAppCloseSequence() {
+	     *     // to unsubscribe the handler, simply call:
+	     *     subscription.unsubscribe();
+	     * }
+	     * ```
+	     */
+	    async registerIntentHandler(handler, intentName, options) {
+	        this.wire.sendAction('interop-client-register-intent-handler').catch((e) => {
+	            // don't expose, this is only for api analytics purposes
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        const handlerId = `intent-handler-${intentName}`;
+	        const wrappedHandler = (0, utils_1.wrapIntentHandler)(handler, handlerId);
+	        try {
+	            await client.register(handlerId, wrappedHandler);
+	            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
+	        }
+	        catch (error) {
+	            throw new Error('Unable to register intent handler');
+	        }
+	        return {
+	            unsubscribe: async () => {
+	                client.remove(handlerId);
+	            }
+	        };
+	    }
+	    /**
+	     * Gets the last context of the Context Group currently subscribed to. It takes an optional Context Type and returns the
+	     * last context of that type.
+	     * @param contextType
+	     *
+	     * @example
+	     * ```js
+	     * await fin.me.interop.joinContextGroup('yellow');
+	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+	     * const currentContext = await fin.me.interop.getCurrentContext();
+	     *
+	     * // with a specific context
+	     * await fin.me.interop.joinContextGroup('yellow');
+	     * await fin.me.interop.setContext({ type: 'country', id: { ISOALPHA3: 'US' }});
+	     * await fin.me.interop.setContext({ type: 'instrument', id: { ticker: 'FOO' }});
+	     * const currentContext = await fin.me.interop.getCurrentContext('country');
+	     * ```
+	     */
+	    async getCurrentContext(contextType) {
+	        this.wire.sendAction('interop-client-get-current-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getCurrentContext', { contextType });
+	    }
+	    /**
+	     * Get information for a particular Intent from the Interop Broker.
+	     *
+	     * @remarks To resolve this info, the function handleInfoForIntent is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param options
+	     *
+	     * @example
+	     * ```js
+	     * const intentInfo = await fin.me.interop.getInfoForIntent('ViewChart');
+	     * ```
+	     */
+	    async getInfoForIntent(options) {
+	        this.wire.sendAction('interop-client-get-info-for-intent').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getInfoForIntent', options);
+	    }
+	    /**
+	     * Get information from the Interop Broker on all Intents that are meant to handle a particular context.
+	     *
+	     * @remarks To resolve this info, the function handleInfoForIntentsByContext is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *
+	     *     const context = {
+	     *         type: 'fdc3.instrument',
+	     *         id: {
+	     *             ticker
+	     *         }
+	     *     }
+	     *
+	     *     const intentsInfo = await fin.me.interop.getInfoForIntentByContext(context);
+	     * })
+	     * ```
+	     */
+	    async getInfoForIntentsByContext(context) {
+	        this.wire.sendAction('interop-client-get-info-for-intents-by-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('getInfoForIntentsByContext', context);
+	    }
+	    /**
+	     * Sends a Context that will be resolved to an Intent by the Interop Broker.
+	     * This context accepts a metadata property.
+	     *
+	     * @remarks To resolve this info, the function handleFiredIntentByContext is meant to be overridden in the Interop Broker.
+	     * The format for the response will be determined by the App Provider overriding the function.
+	     *
+	     * @param context
+	     *
+	     * @example
+	     * ```js
+	     * tickerElement.on('click', (element) => {
+	     *     const ticker = element.innerText;
+	     *
+	     *     const context = {
+	     *         type: 'fdc3.instrument',
+	     *         id: {
+	     *             ticker
+	     *         }
+	     *     }
+	     *
+	     *     const intentResolution = await fin.me.interop.fireIntentForContext(context);
+	     * })
+	     * ```
+	     */
+	    async fireIntentForContext(context) {
+	        this.wire.sendAction('interop-client-fire-intent-for-context').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.dispatch('fireIntentForContext', context);
+	    }
+	    /**
+	     * Join the current entity to session context group `sessionContextGroupId` and return a sessionContextGroup instance.
+	     * If the sessionContextGroup doesn't exist, one will get created.
+	     *
+	     * @remarks Session Context Groups do not persist between runs and aren't present on snapshots.
+	     * @param sessionContextGroupId - Id of the context group.
+	     *
+	     * @example
+	     * Say we want to have a Session Context Group that holds UI theme information for all apps to consume:
+	     *
+	     * My color-picker View:
+	     * ```js
+	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+	     *
+	     *     const myColorPickerElement = document.getElementById('color-palette-picker');
+	     *     myColorPickerElement.addEventListener('change', event => {
+	     *         themeSessionContextGroup.setContext({ type: 'color-palette', selection: event.value });
+	     *     });
+	     * ```
+	     *
+	     * In other views:
+	     * ```js
+	     *     const themeSessionContextGroup = await fin.me.interop.joinSessionContextGroup('theme');
+	     *
+	     *     const changeColorPalette = ({ selection }) => {
+	     *         // change the color palette to the selection
+	     *     };
+	     *
+	     *     // If the context is already set by the time the handler was set, the handler will get invoked immediately with the current context.
+	     *     themeSessionContextGroup.addContextHandler(changeColorPalette, 'color-palette');
+	     * ```
+	     */
+	    async joinSessionContextGroup(sessionContextGroupId) {
+	        try {
+	            const currentSessionContextGroup = __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
+	            if (currentSessionContextGroup) {
+	                return currentSessionContextGroup.getUserInstance();
+	            }
+	            const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	            const { hasConflict } = await client.dispatch('sessionContextGroup:createIfNeeded', {
+	                sessionContextGroupId
+	            });
+	            if (hasConflict) {
+	                console.warn(`A (non-session) context group with the name "${sessionContextGroupId}" already exists. If you are trying to join a Context Group, call joinContextGroup instead.`);
+	            }
+	            const newSessionContextGroup = new SessionContextGroupClient_1.default(this.wire, __classPrivateFieldGet(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
+	            __classPrivateFieldGet(this, _InteropClient_sessionContextGroups, "f").set(sessionContextGroupId, newSessionContextGroup);
+	            return newSessionContextGroup.getUserInstance();
+	        }
+	        catch (error) {
+	            console.error(`Error thrown trying to create Session Context Group with id "${sessionContextGroupId}": ${error}`);
+	            throw error;
+	        }
+	    }
+	    /**
+	     * Register a listener that is called when the Interop Client has been disconnected from the Interop Broker.
+	     * Only one listener per Interop Client can be set.
+	     * @param listener
+	     *
+	     * @example
+	     * ```js
+	     * const listener = (event) => {
+	     *     const { type, topic, brokerName} = event;
+	     *     console.log(`Disconnected from Interop Broker ${brokerName} `);
+	     * }
+	     *
+	     * await fin.me.interop.onDisconnection(listener);
+	     * ```
+	     */
+	    async onDisconnection(listener) {
+	        this.wire.sendAction('interop-client-add-ondisconnection-listener').catch((e) => {
+	            // don't expose, analytics-only call
+	        });
+	        const client = await __classPrivateFieldGet(this, _InteropClient_clientPromise, "f");
+	        return client.onDisconnection((event) => {
+	            const { uuid } = event;
+	            listener({ type: 'interop-broker', topic: 'disconnected', brokerName: uuid });
+	        });
+	    }
+	    getFDC3Sync(version) {
+	        switch (version) {
+	            case '1.2':
+	                return new fdc3_1_2_1.Fdc3Module(() => this, this.wire);
+	            case '2.0':
+	                return new fdc3_2_0_1.Fdc3Module2(() => this, this.wire);
+	            default:
+	                throw new Error(`Invalid FDC3 version provided: ${version}. Must be '1.2' or '2.0'`);
+	        }
+	    }
+	    async getFDC3(version) {
+	        return this.getFDC3Sync(version);
+	    }
+	    /**
+	     * @internal
+	     *
+	     * Used to ferry fdc3-only calls from the fdc3 shim to the Interop Broker
+	     */
+	    static async ferryFdc3Call(interopClient, action, payload) {
+	        const client = await __classPrivateFieldGet(interopClient, _InteropClient_clientPromise, "f");
+	        return client.dispatch(action, payload || null);
+	    }
+	};
+	InteropClient.InteropClient = InteropClient$1;
+	_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
+	return InteropClient;
+}
 
-var hasRequiredOverrideCheck;
+var overrideCheck$1 = {};
 
-function requireOverrideCheck () {
-	if (hasRequiredOverrideCheck) return overrideCheck;
-	hasRequiredOverrideCheck = 1;
-	Object.defineProperty(overrideCheck, "__esModule", { value: true });
-	overrideCheck.overrideCheck = overrideCheck.checkFDC32Overrides = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;
-	const InteropBroker_1 = requireInteropBroker();
-	function getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {
-	    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;
-	    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;
-	}
-	overrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;
-	function checkFDC32Overrides(overriddenBroker) {
-	    // These are the APIs that must be overridden for FDC3 2.0 compliance
-	    const mustOverrideAPIs = [
-	        'fdc3HandleFindInstances',
-	        'handleInfoForIntent',
-	        'handleInfoForIntentsByContext',
-	        'fdc3HandleGetAppMetadata',
-	        'fdc3HandleGetInfo',
-	        'fdc3HandleOpen',
-	        'handleFiredIntent',
-	        'handleFiredIntentForContext'
-	    ];
-	    return mustOverrideAPIs.filter((api) => {
-	        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];
-	    });
-	}
-	overrideCheck.checkFDC32Overrides = checkFDC32Overrides;
-	function overrideCheck$1(overriddenBroker, fdc3InteropApi) {
-	    if (fdc3InteropApi && fdc3InteropApi === '2.0') {
-	        const notOverridden = checkFDC32Overrides(overriddenBroker);
-	        if (notOverridden.length > 0) {
-	            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\nThe following APIs need to be overridden:\n${notOverridden.join('\n')}`);
-	        }
-	    }
-	}
-	overrideCheck.overrideCheck = overrideCheck$1;
-	return overrideCheck;
+Object.defineProperty(overrideCheck$1, "__esModule", { value: true });
+overrideCheck$1.overrideCheck = overrideCheck$1.checkFDC32Overrides = overrideCheck$1.getDefaultViewFdc3VersionFromAppInfo = void 0;
+const InteropBroker_1 = requireInteropBroker();
+function getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {
+    const setVersion = manifest?.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;
+    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;
+}
+overrideCheck$1.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;
+function checkFDC32Overrides(overriddenBroker) {
+    // These are the APIs that must be overridden for FDC3 2.0 compliance
+    const mustOverrideAPIs = [
+        'fdc3HandleFindInstances',
+        'handleInfoForIntent',
+        'handleInfoForIntentsByContext',
+        'fdc3HandleGetAppMetadata',
+        'fdc3HandleGetInfo',
+        'fdc3HandleOpen',
+        'handleFiredIntent',
+        'handleFiredIntentForContext'
+    ];
+    return mustOverrideAPIs.filter((api) => {
+        return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];
+    });
+}
+overrideCheck$1.checkFDC32Overrides = checkFDC32Overrides;
+function overrideCheck(overriddenBroker, fdc3InteropApi) {
+    if (fdc3InteropApi && fdc3InteropApi === '2.0') {
+        const notOverridden = checkFDC32Overrides(overriddenBroker);
+        if (notOverridden.length > 0) {
+            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\nThe following APIs need to be overridden:\n${notOverridden.join('\n')}`);
+        }
+    }
 }
+overrideCheck$1.overrideCheck = overrideCheck;
 
 var hasRequiredFactory;
 
@@ -15234,8 +16419,8 @@ function requireFactory () {
 	const inaccessibleObject_1 = inaccessibleObject;
 	const base_1 = base;
 	const InteropBroker_1 = requireInteropBroker();
-	const InteropClient_1 = InteropClient$1;
-	const overrideCheck_1 = requireOverrideCheck();
+	const InteropClient_1 = requireInteropClient();
+	const overrideCheck_1 = overrideCheck$1;
 	const common_utils_1 = commonUtils;
 	const defaultOverride = (Class) => new Class();
 	const BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';
@@ -15268,12 +16453,8 @@ function requireFactory () {
 	        const options = await this.wire.environment.getInteropInfo(this.wire.getFin());
 	        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);
 	        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, lodash_1.cloneDeep)(options));
-	        let provider;
 	        const getProvider = () => {
-	            if (!provider) {
-	                provider = this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
-	            }
-	            return provider;
+	            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
 	        };
 	        const throwingGetProvider = async () => {
 	            // eslint-disable-next-line no-console
@@ -15319,7 +16500,11 @@ function requireFactory () {
 	        this.wire.sendAction('interop-connect-sync').catch(() => {
 	            // don't expose, analytics-only call
 	        });
-	        return new InteropClient_1.InteropClient(this.wire, name, interopConfig);
+	        return new InteropClient_1.InteropClient(this.wire, this.wire.environment.whenReady().then(() => {
+	            return this.fin.InterApplicationBus.Channel.connect(`interop-broker-${name}`, {
+	                payload: interopConfig
+	            });
+	        }));
 	    }
 	}
 	Factory$1.InteropModule = InteropModule;
@@ -15356,7 +16541,7 @@ function requireInterop () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		__exportStar(requireFactory(), exports);
-		__exportStar(InteropClient$1, exports);
+		__exportStar(requireInteropClient(), exports);
 		__exportStar(requireInteropBroker(), exports); 
 	} (interop));
 	return interop;
@@ -16088,7 +17273,7 @@ class MockEnvironment {
         throw new Error(me_1.environmentUnsupportedMessage);
     }
     getNextMessageId() {
-        throw new Error(me_1.environmentUnsupportedMessage);
+        return `mock-message-id-${Math.random()}`;
     }
     getRandomId() {
         throw new Error(me_1.environmentUnsupportedMessage);