@openfin/remote-adapter 37.80.39 → 37.81.20

package/out/remote-adapter.js

@@ -1,7 +1,7 @@
 'use strict';
 
-var require$$0 = require('lodash');
-var require$$0$1 = require('events');
+var require$$3 = require('lodash');
+var require$$0 = require('events');
 var bridge = require('./bridge-ef11968f.js');
 var crypto = require('crypto');
 var backchannel = require('./backchannel.js');
@@ -48,13 +48,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);
@@ -141,8 +141,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) => {
@@ -180,7 +180,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) : [];
     }
     /**
@@ -298,7 +298,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"));
         }
     }
 }
@@ -365,11 +365,11 @@ function createWarningObject(message, obj) {
 }
 inaccessibleObject.createWarningObject = createWarningObject;
 
-var InteropClient$1 = {};
+var InteropClient = {};
 
 var SessionContextGroupClient$1 = {};
 
-var utils$1 = {};
+var utils$3 = {};
 
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
@@ -432,29 +432,29 @@ var utils$1 = {};
 	    };
 	};
 	exports.wrapIntentHandler = wrapIntentHandler; 
-} (utils$1));
+} (utils$3));
 
-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);
 };
 var _SessionContextGroupClient_clientPromise;
 Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
-const base_1$k = base;
-const utils_1$3 = utils$1;
-class SessionContextGroupClient extends base_1$k.Base {
+const base_1$j = base;
+const utils_1$2 = utils$3;
+class SessionContextGroupClient extends base_1$j.Base {
     constructor(wire, client, id) {
         super(wire);
         _SessionContextGroupClient_clientPromise.set(this, void 0);
         this.id = id;
-        __classPrivateFieldSet$c(this, _SessionContextGroupClient_clientPromise, client, "f");
+        __classPrivateFieldSet$b(this, _SessionContextGroupClient_clientPromise, client, "f");
     }
     /**
      * Sets a context for the session context group.
@@ -466,7 +466,7 @@ class SessionContextGroupClient extends base_1$k.Base {
         this.wire.sendAction('interop-session-context-group-set-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet$e(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$d(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:setContext-${this.id}`, {
             sessionContextGroupId: this.id,
             context
@@ -476,7 +476,7 @@ class SessionContextGroupClient extends base_1$k.Base {
         this.wire.sendAction('interop-session-context-group-get-context').catch((e) => {
             // don't expose, analytics-only call
         });
-        const client = await __classPrivateFieldGet$e(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$d(this, _SessionContextGroupClient_clientPromise, "f");
         return client.dispatch(`sessionContextGroup:getContext-${this.id}`, {
             sessionContextGroupId: this.id,
             type
@@ -489,20 +489,20 @@ class SessionContextGroupClient extends base_1$k.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$e(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$d(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$e(this, _SessionContextGroupClient_clientPromise, "f");
+        const client = await __classPrivateFieldGet$d(this, _SessionContextGroupClient_clientPromise, "f");
         return async () => {
             client.remove(handlerId);
             await client.dispatch(`sessionContextGroup:handlerRemoved-${this.id}`, { handlerId });
@@ -511,610 +511,1770 @@ class SessionContextGroupClient extends base_1$k.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$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$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);
-};
-var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
-Object.defineProperty(InteropClient$1, "__esModule", { value: true });
-InteropClient$1.InteropClient = void 0;
-const base_1$j = 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$j.Base {
-    /**
-     * @internal
-     */
-    constructor(wire, name, interopConfig = {}) {
-        super(wire);
-        _InteropClient_clientPromise.set(this, void 0);
-        _InteropClient_sessionContextGroups.set(this, void 0);
-        __classPrivateFieldSet$b(this, _InteropClient_sessionContextGroups, new Map(), "f");
-        __classPrivateFieldSet$b(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$d(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$d(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';
-        }
-        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 });
-            }
-        };
-    }
-    /*
-    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$d(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$d(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for joinContextGroup.');
+            handlerId = `contextHandler:invoke-${this.id}-${utils$1.generateId()}`;
         }
-        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$d(this, _InteropClient_clientPromise, "f");
-        return client.dispatch('removeFromContextGroup', { target });
+        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;
     }
-    /**
-     * 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$d(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for getAllClientsInContextGroup.');
-        }
-        return client.dispatch('getAllClientsInContextGroup', { contextGroupId });
+    createNonStandardUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('nonStandardHandlerRemoved', { handlerId });
+        };
     }
-    /**
-     * 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$d(this, _InteropClient_clientPromise, "f");
-        if (!contextGroupId) {
-            throw new Error('No contextGroupId specified for getInfoForContextGroup.');
-        }
-        return client.dispatch('getInfoForContextGroup', { contextGroupId });
+    createContextUnsubscribeCb(handlerId) {
+        return async () => {
+            this.client.remove(handlerId);
+            this.listeners.delete(handlerId);
+            await this.client.dispatch('contextHandlerRemoved', { handlerId });
+        };
     }
-    /**
-     * 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
+    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$d(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$d(this, _InteropClient_clientPromise, "f");
-        const handlerId = `intent-handler-${intentName}`;
-        const wrappedHandler = (0, utils_1$2.wrapIntentHandler)(handler, handlerId);
+    async disconnect() {
         try {
-            await client.register(handlerId, wrappedHandler);
-            await client.dispatch('intentHandlerRegistered', { handlerId, ...options });
+            await this.client.dispatch('clientDisconnecting');
+            await this.cleanUpAllSubs();
+            await this.client.disconnect();
         }
         catch (error) {
-            throw new Error('Unable to register intent handler');
+            throw new Error(error.message);
         }
-        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$d(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$d(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$d(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$d(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$d(this, _InteropClient_sessionContextGroups, "f").get(sessionContextGroupId);
-            if (currentSessionContextGroup) {
-                return currentSessionContextGroup.getUserInstance();
-            }
-            const client = await __classPrivateFieldGet$d(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$d(this, _InteropClient_clientPromise, "f"), sessionContextGroupId);
-            __classPrivateFieldGet$d(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$d(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$d(interopClient, _InteropClient_clientPromise, "f");
-        return client.dispatch(action, payload || null);
     }
 }
-InteropClient$1.InteropClient = InteropClient;
-_InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
+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);
+	     * ```
+	     *
+	     *
+	     * Passing in a context type as the second parameter will cause the handler to only be invoked with that context type.
+	     *
+	     * ```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)()}`;
+	        }
+	        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 commonUtils = {};
 
@@ -1145,11 +2305,11 @@ function requireFactory$3 () {
 	hasRequiredFactory$3 = 1;
 	Object.defineProperty(Factory$8, "__esModule", { value: true });
 	Factory$8.InteropModule = void 0;
-	const lodash_1 = require$$0;
+	const lodash_1 = require$$3;
 	const inaccessibleObject_1 = inaccessibleObject;
 	const base_1 = base;
 	const InteropBroker_1 = requireInteropBroker();
-	const InteropClient_1 = InteropClient$1;
+	const InteropClient_1 = requireInteropClient();
 	const overrideCheck_1 = requireOverrideCheck();
 	const common_utils_1 = commonUtils;
 	const defaultOverride = (Class) => new Class();
@@ -1183,12 +2343,8 @@ function requireFactory$3 () {
 	        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
@@ -1234,7 +2390,11 @@ function requireFactory$3 () {
 	        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$8.InteropModule = InteropModule;
@@ -1271,7 +2431,7 @@ function requireInterop () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		__exportStar(requireFactory$3(), exports);
-		__exportStar(InteropClient$1, exports);
+		__exportStar(requireInteropClient(), exports);
 		__exportStar(requireInteropBroker(), exports); 
 	} (interop));
 	return interop;
@@ -1676,6 +2836,62 @@ function requirePrivateChannelProvider () {
 	return PrivateChannelProvider;
 }
 
+var lazy = {};
+
+Object.defineProperty(lazy, "__esModule", { value: true });
+lazy.AsyncRetryableLazy = lazy.Lazy = void 0;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call the producer function once and only once when getValue is called,
+ * returning the resultant value for every subsequent call.
+ */
+class Lazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the producer.
+     * @returns The value returned from the producer function
+     */
+    getValue() {
+        if (!this.value) {
+            this.value = this.producerFn();
+        }
+        return this.value;
+    }
+}
+lazy.Lazy = Lazy;
+/**
+ * Handy class for managing asynchronous dependencies of classes.
+ *
+ * Will call asynchronous producer only after `getValue` is called.  If the
+ * deferred code errors, we can try it again by re-calling `getValue` after
+ * the promise rejects.
+ */
+class AsyncRetryableLazy {
+    // eslint-disable-next-line
+    constructor(producerFn) {
+        this.producerFn = producerFn;
+    }
+    /**
+     * Lazily get the value returned by the async producer.
+     *
+     * @returns The value returned from the producer function
+     */
+    async getValue() {
+        if (!this.promise) {
+            this.promise = this.producerFn().catch((e) => {
+                delete this.promise;
+                throw e;
+            });
+        }
+        return this.promise;
+    }
+}
+lazy.AsyncRetryableLazy = AsyncRetryableLazy;
+
 var hasRequiredInteropBroker;
 
 function requireInteropBroker () {
@@ -1692,14 +2908,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 lodash_1 = require$$0;
+	const utils_1 = utils$3;
+	const lodash_1 = require$$3;
 	const PrivateChannelProvider_1 = requirePrivateChannelProvider();
+	const lazy_1 = lazy;
 	const defaultContextGroups = [
 	    {
 	        id: 'green',
@@ -1867,12 +3084,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");
@@ -1883,6 +3103,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();
 	    }
@@ -2966,7 +4187,7 @@ 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;
 }
 
@@ -3239,7 +4460,7 @@ var emitterMap = {};
 
 Object.defineProperty(emitterMap, "__esModule", { value: true });
 emitterMap.EmitterMap = void 0;
-const events_1$6 = require$$0$1;
+const events_1$6 = require$$0;
 class EmitterMap {
     constructor() {
         this.storage = new Map();
@@ -3497,62 +4718,6 @@ function requireFactory$2 () {
 
 var Instance$7 = {};
 
-var lazy = {};
-
-Object.defineProperty(lazy, "__esModule", { value: true });
-lazy.AsyncRetryableLazy = lazy.Lazy = void 0;
-/**
- * Handy class for managing asynchronous dependencies of classes.
- *
- * Will call the producer function once and only once when getValue is called,
- * returning the resultant value for every subsequent call.
- */
-class Lazy {
-    // eslint-disable-next-line
-    constructor(producerFn) {
-        this.producerFn = producerFn;
-    }
-    /**
-     * Lazily get the value returned by the producer.
-     * @returns The value returned from the producer function
-     */
-    getValue() {
-        if (!this.value) {
-            this.value = this.producerFn();
-        }
-        return this.value;
-    }
-}
-lazy.Lazy = Lazy;
-/**
- * Handy class for managing asynchronous dependencies of classes.
- *
- * Will call asynchronous producer only after `getValue` is called.  If the
- * deferred code errors, we can try it again by re-calling `getValue` after
- * the promise rejects.
- */
-class AsyncRetryableLazy {
-    // eslint-disable-next-line
-    constructor(producerFn) {
-        this.producerFn = producerFn;
-    }
-    /**
-     * Lazily get the value returned by the async producer.
-     *
-     * @returns The value returned from the producer function
-     */
-    async getValue() {
-        if (!this.promise) {
-            this.promise = this.producerFn().catch((e) => {
-                delete this.promise;
-                throw e;
-            });
-        }
-        return this.promise;
-    }
-}
-lazy.AsyncRetryableLazy = AsyncRetryableLazy;
-
 var layoutEntities = {};
 
 var apiExposer$1 = {};
@@ -6430,6 +7595,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$1;
 
 function requireInstance$1 () {
@@ -6445,6 +7641,7 @@ function requireInstance$1 () {
 	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.
@@ -6460,79 +7657,60 @@ function requireInstance$1 () {
 	    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
@@ -8997,7 +10175,7 @@ var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateF
 var _Transport_wire, _Transport_fin;
 Object.defineProperty(transport, "__esModule", { value: true });
 var Transport_1 = transport.Transport = void 0;
-const events_1$5 = require$$0$1;
+const events_1$5 = require$$0;
 const wire_1 = wire;
 const transport_errors_1$2 = transportErrors;
 const eventAggregator_1 = eventAggregator;
@@ -9214,7 +10392,7 @@ _Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();
 var websocket = {};
 
 Object.defineProperty(websocket, "__esModule", { value: true });
-const events_1$4 = require$$0$1;
+const events_1$4 = require$$0;
 const transport_errors_1$1 = transportErrors;
 const messageReceiver_1 = bridge.messageReceiver;
 /* `READY_STATE` is an instance var set by `constructor` to reference the `WebTransportSocket.READY_STATE` enum.
@@ -9291,7 +10469,7 @@ system.System = void 0;
 const base_1$d = base;
 const transport_errors_1 = transportErrors;
 const window_1 = requireWindow();
-const events_1$3 = require$$0$1;
+const events_1$3 = require$$0;
 /**
  * An object representing the core of OpenFin Runtime. Allows the developer
  * to perform system-level actions, such as accessing logs, viewing processes,
@@ -11204,9 +12382,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;
@@ -11593,7 +12772,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
     /**
      * @internal
      */
-    constructor(routingInfo, wire, strategy) {
+    constructor(routingInfo, close, strategy) {
         super();
         _ChannelClient_protectedObj.set(this, void 0);
         _ChannelClient_strategy.set(this, void 0);
@@ -11603,7 +12782,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
             channelClientsByEndpointId.delete(this.endpointId);
             __classPrivateFieldGet$a(this, _ChannelClient_strategy, "f").close();
         });
-        __classPrivateFieldSet$8(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, wire), "f");
+        __classPrivateFieldSet$8(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
         this.disconnectListener = () => undefined;
         this.endpointId = routingInfo.endpointId;
         __classPrivateFieldSet$8(this, _ChannelClient_strategy, strategy, "f");
@@ -11698,12 +12877,19 @@ class ChannelClient extends channel_1$1.ChannelBase {
     }
     async sendDisconnectAction() {
         const protectedObj = __classPrivateFieldGet$a(this, _ChannelClient_protectedObj, "f");
-        const { channelName, uuid, name } = protectedObj.providerIdentity;
-        await protectedObj.wire.sendAction('disconnect-from-channel', {
+        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
         });
     }
 }
@@ -12299,7 +13485,7 @@ 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);
@@ -12327,7 +13513,7 @@ class ChannelProvider extends channel_1.ChannelBase {
                 remove();
             }
         });
-        __classPrivateFieldSet$4(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, wire), "f");
+        __classPrivateFieldSet$4(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
         this.connectListener = () => undefined;
         this.disconnectListener = () => undefined;
         __classPrivateFieldSet$4(this, _ChannelProvider_connections, [], "f");
@@ -12466,9 +13652,9 @@ class ChannelProvider extends channel_1.ChannelBase {
      */
     async destroy() {
         const protectedObj = __classPrivateFieldGet$6(this, _ChannelProvider_protectedObj, "f");
-        const { channelName } = protectedObj.providerIdentity;
+        protectedObj.providerIdentity;
         __classPrivateFieldSet$4(this, _ChannelProvider_connections, [], "f");
-        await protectedObj.wire.sendAction('destroy-channel', { channelName });
+        await protectedObj.close();
         __classPrivateFieldGet$6(this, _ChannelProvider_close, "f").call(this);
     }
     /**
@@ -12560,6 +13746,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();
@@ -12829,7 +14018,7 @@ class ConnectionManager extends base_1$a.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,
@@ -13014,7 +14203,7 @@ var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnec
 Object.defineProperty(channel$1, "__esModule", { value: true });
 channel$1.Channel = void 0;
 /* eslint-disable no-console */
-const events_1$2 = require$$0$1;
+const events_1$2 = require$$0;
 const lazy_1$1 = lazy;
 const base_1$9 = base;
 const client_1 = client;
@@ -13250,7 +14439,7 @@ class Channel extends base_1$9.EmitterBase {
         };
         const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
         const strategy = await __classPrivateFieldGet$4(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
-        const channel = new client_1.ChannelClient(routingInfo, this.wire, strategy);
+        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.
@@ -13341,7 +14530,7 @@ interappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;
  *
  * @packageDocumentation
  */
-const events_1$1 = require$$0$1;
+const events_1$1 = require$$0;
 const base_1$8 = base;
 const ref_counter_1 = refCounter;
 const index_1$2 = channel$1;
@@ -15904,7 +17093,7 @@ Factory.SnapshotSourceModule = SnapshotSourceModule;
 
 Object.defineProperty(fin$1, "__esModule", { value: true });
 var Fin_1 = fin$1.Fin = void 0;
-const events_1 = require$$0$1;
+const events_1 = require$$0;
 // Import from the file rather than the directory in case someone consuming types is using module resolution other than "node"
 const index_1 = system;
 const index_2 = requireWindow();