@openfin/remote-adapter 39.83.21 → 40.82.1

package/out/remote-adapter.js

@@ -1,8 +1,7 @@
 'use strict';
 
-var require$$0 = require('lodash/cloneDeep');
-var require$$3 = require('lodash/isEqual');
-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');
@@ -526,32 +525,9 @@ var utils$2 = {};
 
 var PrivateChannelClient$1 = {};
 
-var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (commonjsGlobal && commonjsGlobal.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 Object.defineProperty(PrivateChannelClient$1, "__esModule", { value: true });
 PrivateChannelClient$1.PrivateChannelClient = void 0;
-const utils$1 = __importStar(utils$3);
+const utils$1 = utils$3;
 class PrivateChannelClient {
     constructor(client, id) {
         this.id = id;
@@ -640,14 +616,11 @@ class PrivateChannelClient {
 PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
 
 (function (exports) {
-	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
 	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 isEqual_1 = __importDefault(require$$3);
+	const lodash_1 = require$$3;
 	const getUnsupportedChannelApis = (channelType) => {
 	    return {
 	        addContextListener: () => {
@@ -775,7 +748,7 @@ PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
 	                const wrappedHandler = (context, contextMetadata) => {
 	                    if (first) {
 	                        first = false;
-	                        if ((0, isEqual_1.default)(currentContext, context)) {
+	                        if ((0, lodash_1.isEqual)(currentContext, context)) {
 	                            return;
 	                        }
 	                    }
@@ -897,16 +870,13 @@ function requireFdc3Common () {
 	    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 __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
 	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 isEqual_1 = __importDefault(require$$3);
+	const lodash_1 = require$$3;
 	class FDC3ModuleBase {
 	    get client() {
 	        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
@@ -1095,7 +1065,7 @@ function requireFdc3Common () {
 	                    const wrappedHandler = (context, contextMetadata) => {
 	                        if (first) {
 	                            first = false;
-	                            if ((0, isEqual_1.default)(currentContext, context)) {
+	                            if ((0, lodash_1.isEqual)(currentContext, context)) {
 	                                return;
 	                            }
 	                        }
@@ -1708,14 +1678,11 @@ function requireInteropClient () {
 	    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 __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
 	var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
 	Object.defineProperty(InteropClient, "__esModule", { value: true });
 	InteropClient.InteropClient = void 0;
 	const base_1 = base;
-	const SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);
+	const SessionContextGroupClient_1 = SessionContextGroupClient$1;
 	const fdc3_1_2_1 = requireFdc31_2();
 	const fdc3_2_0_1 = requireFdc32_0();
 	const utils_1 = utils$3;
@@ -2333,12 +2300,9 @@ var hasRequiredFactory$3;
 function requireFactory$3 () {
 	if (hasRequiredFactory$3) return Factory$8;
 	hasRequiredFactory$3 = 1;
-	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
 	Object.defineProperty(Factory$8, "__esModule", { value: true });
 	Factory$8.InteropModule = void 0;
-	const cloneDeep_1 = __importDefault(require$$0);
+	const lodash_1 = require$$3;
 	const inaccessibleObject_1 = inaccessibleObject;
 	const base_1 = base;
 	const InteropBroker_1 = requireInteropBroker();
@@ -2375,7 +2339,7 @@ function requireFactory$3 () {
 	        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)
 	        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, cloneDeep_1.default)(options));
+	        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, lodash_1.cloneDeep)(options));
 	        const getProvider = () => {
 	            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
 	        };
@@ -2941,16 +2905,13 @@ 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 __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-	    return (mod && mod.__esModule) ? mod : { "default": mod };
-	};
 	var _InteropBroker_fdc3Info, _InteropBroker_contextGroups, _InteropBroker_providerPromise;
 	Object.defineProperty(InteropBroker, "__esModule", { value: true });
 	InteropBroker.InteropBroker = void 0;
 	const base_1 = base;
-	const SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());
+	const SessionContextGroupBroker_1 = requireSessionContextGroupBroker();
 	const utils_1 = utils$3;
-	const isEqual_1 = __importDefault(require$$3);
+	const lodash_1 = require$$3;
 	const PrivateChannelProvider_1 = requirePrivateChannelProvider();
 	const lazy_1 = lazy;
 	const defaultContextGroups = [
@@ -3148,7 +3109,7 @@ function requireInteropBroker () {
 	            constructor(...unused) {
 	                if (unused.length) {
 	                    const [_ignore1, ignore2, opts] = unused;
-	                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(opts, args[2])) {
+	                    if (opts && typeof opts === 'object' && !(0, lodash_1.isEqual)(opts, args[2])) {
 	                        // eslint-disable-next-line no-console
 	                        console.warn('You have modified the parameters of the InteropOverride constructor. This behavior is deprecated and will be removed in a future version. You can modify these options in your manifest. Please consult our Interop docs for guidance on migrating to the new override scheme.');
 	                        super(args[0], args[1], opts);
@@ -4273,10 +4234,6 @@ Object.defineProperty(baseEnv, "__esModule", { value: true });
 baseEnv.BaseEnvironment = void 0;
 const overrideCheck_1 = requireOverrideCheck();
 class BaseEnvironment {
-    async getViewWindowIdentity(fin, viewIdentity) {
-        const { identity } = await fin.View.wrapSync(viewIdentity).getCurrentWindow();
-        return identity;
-    }
     async getInteropInfo(fin) {
         const appInfo = await fin.Application.getCurrentSync()
             .getInfo()
@@ -4507,7 +4464,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();
@@ -4684,9 +4641,7 @@ function requireFactory$2 () {
 	     * @experimental
 	     */
 	    async wrap(identity) {
-	        this.wire.sendAction('view-wrap').catch((e) => {
-	            // we do not want to expose this error, just continue if this analytics-only call fails
-	        });
+	        this.wire.sendAction('view-wrap');
 	        const errorMsg = (0, validate_1.validateIdentity)(identity);
 	        if (errorMsg) {
 	            throw new Error(errorMsg);
@@ -4767,937 +4722,1601 @@ function requireFactory$2 () {
 
 var Instance$7 = {};
 
-var main = {};
+var layoutEntities = {};
 
-Object.defineProperty(main, "__esModule", { value: true });
-main.WebContents = void 0;
-const base_1$i = base;
-class WebContents extends base_1$i.EmitterBase {
-    /**
-     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
-     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
-     */
-    constructor(wire, identity, entityType) {
-        super(wire, entityType, identity.uuid, identity.name);
-        this.identity = identity;
-        this.entityType = entityType;
+var apiExposer$1 = {};
+
+var apiConsumer = {};
+
+Object.defineProperty(apiConsumer, "__esModule", { value: true });
+apiConsumer.ApiConsumer = void 0;
+/**
+ * Consumer for apis exposed with {@see ApiExposer}.
+ *
+ * A strategy that matches the strategy used to expose a target API must be provided.
+ */
+class ApiConsumer {
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Consumes an api exposed using a given transport strategy, and generates a client
+         * for easy, type safe consumption of that client.
+         * @param options Strategy specific consumption options.
+         * @returns An api client matching the given type.
+         */
+        this.consume = async (options) => {
+            const exposedProperties = await this.strategy.getExposedFunctions(options);
+            return exposedProperties.reduce((client, prop) => ({
+                ...client,
+                [prop.key]: this.strategy.createFunction(prop, options)
+            }), {});
+        };
     }
+}
+apiConsumer.ApiConsumer = ApiConsumer;
+
+var apiExposer = {};
+
+var decorators = {};
+
+Object.defineProperty(decorators, "__esModule", { value: true });
+decorators.expose = decorators.getExposedProperties = void 0;
+const exposedProperties = Symbol('exposedProperties');
+const getExposedProperties = (target) => {
+    return target[exposedProperties] || target.prototype[exposedProperties] || [];
+};
+decorators.getExposedProperties = getExposedProperties;
+/**
+ * Indicates that a class member function can be exposed using {@link ApiExposer}.
+ * @param options Options specific to the strategy used in {@link ApiExposer}
+ */
+// Returns any as decorator typing is weird.
+const expose = (options) => (target, key, descriptor) => {
+    target[exposedProperties] = target[exposedProperties] || [];
+    target[exposedProperties].push({ key, descriptor, options });
+};
+decorators.expose = expose;
+
+Object.defineProperty(apiExposer, "__esModule", { value: true });
+apiExposer.ApiExposer = void 0;
+const decorators_1 = decorators;
+/**
+ * Exposes api services on the transport of choice.
+ */
+class ApiExposer {
     /**
-     * Gets a base64 encoded image of all or part of the WebContents.
-     * @param options Options for the capturePage call.
-     *
-     * @example
-     *
-     * View:
-     * ```js
-     * const view = fin.View.getCurrentSync();
-     *
-     * // PNG image of a full visible View
-     * console.log(await view.capturePage());
-     *
-     * // Low-quality JPEG image of a defined visible area of the view
-     * const options = {
-     *     area: {
-     *         height: 100,
-     *         width: 100,
-     *         x: 10,
-     *         y: 10,
-     *     },
-     *     format: 'jpg',
-     *     quality: 20
-     * }
-     * console.log(await view.capturePage(options));
-     * ```
-     *
-     * Window:
-     * ```js
-     * const wnd = await fin.Window.getCurrent();
-     *
-     * // PNG image of a full visible window
-     * console.log(await wnd.capturePage());
-     *
-     * // Low-quality JPEG image of a defined visible area of the window
-     * const options = {
-     *     area: {
-     *         height: 100,
-     *         width: 100,
-     *         x: 10,
-     *         y: 10,
-     *     },
-     *     format: 'jpg',
-     *     quality: 20
-     * }
-     * console.log(await wnd.capturePage(options));
-     * ```
-     *
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
+     * @param strategy The expose strategy to use to expose instances.
      */
-    capturePage(options) {
-        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);
+    // eslint-disable-next-line
+    constructor(strategy) {
+        this.strategy = strategy;
+        /**
+         * Exposes an instance of a given api on
+         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
+         * @param instanceOptions Transport strategy specific options to use when exposing.
+         */
+        this.exposeInstance = async (instance, instanceOptions) => {
+            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
+            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
+                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
+                    key,
+                    options,
+                    meta: instanceOptions
+                });
+                return {
+                    key,
+                    options: customConsumptionOptions
+                };
+            }));
+            await this.strategy.exposeMeta(instanceOptions, exposedProps);
+        };
     }
-    /**
-     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by
-     * applications you have created.
-     * @param code JavaScript code to be executed on the view.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function executeJavaScript(code) {
-     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});
-     *     return await view.executeJavaScript(code);
-     * }
-     *
-     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function executeJavaScript(code) {
-     *     const app = await fin.Application.start({
-     *         name: 'myApp',
-     *         uuid: 'app-1',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',
-     *         autoShow: true
-     *     });
-     *     const win = await app.getWindow();
-     *     return await win.executeJavaScript(code);
-     * }
-     *
-     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    executeJavaScript(code) {
-        return this.wire
-            .sendAction('execute-javascript-in-window', { ...this.identity, code })
-            .then(({ payload }) => payload.data);
+    ;
+}
+apiExposer.ApiExposer = ApiExposer;
+
+var strategies = {};
+
+var openfinChannels = {};
+
+var channelsConsumer = {};
+
+Object.defineProperty(channelsConsumer, "__esModule", { value: true });
+channelsConsumer.ChannelsConsumer = void 0;
+class ChannelsConsumer {
+    // eslint-disable-next-line
+    constructor(channel) {
+        this.channel = channel;
+        this.getExposedFunctions = async (options) => {
+            const { id } = options;
+            const { props } = await this.channel.dispatch(`api-meta:${id}`);
+            return props;
+        };
+        this.createFunction = (prop) => (...args) => {
+            const { action } = prop.options;
+            return this.channel.dispatch(action, { args });
+        };
     }
-    /**
-     * Returns the zoom level of the WebContents.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function getZoomLevel() {
-     *     const view = await fin.View.getCurrent();
-     *     return await view.getZoomLevel();
-     * }
-     *
-     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function createWin() {
-     *     const app = await fin.Application.start({
-     *         name: 'myApp',
-     *         uuid: 'app-1',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',
-     *         autoShow: true
-     *     });
-     *     return await app.getWindow();
-     * }
-     *
-     * async function getZoomLevel() {
-     *     const win = await createWin();
-     *     return await win.getZoomLevel();
-     * }
-     *
-     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    getZoomLevel() {
-        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);
+    ;
+}
+channelsConsumer.ChannelsConsumer = ChannelsConsumer;
+
+var channelsExposer = {};
+
+Object.defineProperty(channelsExposer, "__esModule", { value: true });
+channelsExposer.ChannelsExposer = void 0;
+class ChannelsExposer {
+    // eslint-disable-next-line
+    constructor(channelProviderOrClient) {
+        this.channelProviderOrClient = channelProviderOrClient;
+        this.exposeFunction = async (target, config) => {
+            const { key, options, meta } = config;
+            const { id } = meta;
+            const action = `${id}.${options?.action || key}`;
+            await this.channelProviderOrClient.register(action, async ({ args }) => {
+                return target(...args);
+            });
+            return { action };
+        };
+        this.exposeMeta = async ({ id }, props) => {
+            const action = `api-meta:${id}`;
+            await this.channelProviderOrClient.register(action, () => ({ props }));
+        };
     }
-    /**
-     * Sets the zoom level of the WebContents.
-     * @param level The zoom level
-     *
-     * @example
-     * View:
-     * ```js
-     * async function setZoomLevel(number) {
-     *     const view = await fin.View.getCurrent();
-     *     return await view.setZoomLevel(number);
-     * }
-     *
-     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function createWin() {
-     *     const app = await fin.Application.start({
-     *         name: 'myApp',
-     *         uuid: 'app-1',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',
-     *         autoShow: true
-     *     });
-     *     return await app.getWindow();
-     * }
-     *
-     * async function setZoomLevel(number) {
-     *     const win = await createWin();
-     *     return await win.setZoomLevel(number);
-     * }
-     *
-     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    setZoomLevel(level) {
-        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);
+}
+channelsExposer.ChannelsExposer = ChannelsExposer;
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(channelsConsumer, exports);
+	__exportStar(channelsExposer, exports); 
+} (openfinChannels));
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(openfinChannels, exports); 
+} (strategies));
+
+(function (exports) {
+	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    var desc = Object.getOwnPropertyDescriptor(m, k);
+	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+	      desc = { enumerable: true, get: function() { return m[k]; } };
+	    }
+	    Object.defineProperty(o, k2, desc);
+	}) : (function(o, m, k, k2) {
+	    if (k2 === undefined) k2 = k;
+	    o[k2] = m[k];
+	}));
+	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
+	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+	};
+	Object.defineProperty(exports, "__esModule", { value: true });
+	__exportStar(apiConsumer, exports);
+	__exportStar(apiExposer, exports);
+	__exportStar(strategies, exports);
+	__exportStar(decorators, exports); 
+} (apiExposer$1));
+
+var channelApiRelay = {};
+
+Object.defineProperty(channelApiRelay, "__esModule", { value: true });
+channelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;
+const EXPECTED_ERRORS = [
+    'no longer connected',
+    'RTCDataChannel closed unexpectedly',
+    'The client you are trying to dispatch from is disconnected from the target provider',
+];
+// Checks possible error messages that we want to trap, client error message can originate
+// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose
+const isDisconnectedError = (errorMsg) => {
+    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));
+};
+/**
+ * @internal
+ * Create a channel relay for a given channel exposition, allowing a single provider to route
+ * actions to the designated clients.
+ *
+ * Designed to be used in conjunction with @expose
+ *
+ * @param channelProvider The channel provider to relay the actions on.
+ * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
+ */
+const relayChannelClientApi = async (channelProvider, relayId) => {
+    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
+        return channelProvider.dispatch(target, action, payload);
+    });
+    await Promise.resolve();
+};
+channelApiRelay.relayChannelClientApi = relayChannelClientApi;
+const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
+    try {
+        return await client.dispatch(`relay:${relayId}`, {
+            action,
+            payload,
+            target
+        });
     }
-    /**
-     * Navigates the WebContents to a specified URL.
-     *
-     * Note: The url must contain the protocol prefix such as http:// or https://.
-     * @param url - The URL to navigate the WebContents to.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function createView() {
-     *     const me = await fin.Window.getCurrent();
-     *     return fin.View.create({
-     *         name: 'viewName',
-     *         target: me.identity,
-     *         bounds: {top: 10, left: 10, width: 200, height: 200}
-     *     });
-     * }
-     *
-     * createView()
-     *     .then(view => view.navigate('https://example.com'))
-     *     .then(() => console.log('navigation complete'))
-     *     .catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function navigate() {
-     *     const win = await fin.Window.getCurrent();
-     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');
-     * }
-     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));
-     * ```
-     * @experimental
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    navigate(url) {
-        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);
+    catch (e) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        throw e;
     }
+};
+channelApiRelay.createRelayedDispatch = createRelayedDispatch;
+
+var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    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 _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;
+Object.defineProperty(layoutEntities, "__esModule", { value: true });
+layoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;
+const api_exposer_1 = apiExposer$1;
+const channel_api_relay_1 = channelApiRelay;
+/*
+    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely
+    intertwined, and share members via parent abstract class LayoutNode. To prevent circular
+    refs, we define and export all the classes here.
+*/
+/**
+ * @ignore
+ * @internal
+ * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
+ * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
+ */
+class LayoutNode {
     /**
-     * Navigates the WebContents back one page.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function navigateBack() {
-     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
-     *     await view.navigate('https://www.google.com');
-     *     return await view.navigateBack();
-     * }
-     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function navigateBack() {
-     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
-     *     await win.navigate('https://www.google.com');
-     *     return await win.navigateBack();
-     * }
-     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
+     * @internal
+     * @ignore
      */
-    navigateBack() {
-        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);
+    constructor(client, entityId) {
+        /**
+         * @ignore
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _LayoutNode_client.set(this, void 0);
+        /**
+         * Checks if the TabStack or ColumnOrRow is the root content item
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const isRoot = await stack.isRoot();
+         * // The TabStack is root: false
+         * console.log(`The TabStack is root: ${isRoot}`);
+         *
+         * // Retrieves the parent ColumnOrRow
+         * const parent = await stack.getParent();
+         * const parentIsRoot = await parent.isRoot();
+         * // The parent ColumnOrRow is root: true
+         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);
+         * ```
+         */
+        this.isRoot = () => __classPrivateFieldGet$c(this, _LayoutNode_client, "f").isRoot(this.entityId);
+        /**
+         * Checks if the TabStack or ColumnOrRow exists
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         * let exists = await stack.exists();
+         * // or
+         * let exists = await columnOrRow.exists();
+         * // The entity exists: true
+         * console.log(`The entity exists: ${exists}`);
+         * ```
+         */
+        this.exists = () => __classPrivateFieldGet$c(this, _LayoutNode_client, "f").exists(this.entityId);
+        /**
+         * Retrieves the parent of the TabStack or ColumnOrRow
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         *
+         * // undefined if entity is the root item
+         * let parent = await columnOrRow.getParent();
+         * // or
+         * let parent = await stack.getParent();
+         * ```
+         */
+        this.getParent = async () => {
+            const parent = await __classPrivateFieldGet$c(this, _LayoutNode_client, "f").getParent(this.entityId);
+            if (!parent) {
+                return undefined;
+            }
+            return LayoutNode.getEntity(parent, __classPrivateFieldGet$c(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.
+         *
+         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active
+         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.
+         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.
+         *
+         * @param views The views that will populate the new TabStack.
+         * @param options Additional options that control new TabStack creation.
+         * @returns The newly-created TabStack.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const columnOrRow = await stack.getParent();
+         *
+         * // Create view references by supplying a 'name' and 'url'
+         * const views = [
+         *     // if 'name' is undefined, one will be generated
+         *     // if 'url' is undefined, it will default the view URL to 'about:blank'
+         *     { name: 'google-view', url: 'http://google.com/'},
+         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},
+         * ];
+         *
+         * // Create a view beforehand to be included in the new tab stack
+         * const outsideView = await fin.View.create({
+         *     name: 'outside-bloomberg-view',
+         *     url: 'https://bloomberg.com/',
+         *     target: fin.me.identity,
+         * });
+         *
+         * // Views to add can be identities, or the reference views mentioned above
+         * const viewsToAdd = [outsideView.identity, ...views];
+         *
+         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
+         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });
+         * // Or
+         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });
+         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);
+         *
+         * ```
+         * @experimental
+         */
+        this.createAdjacentStack = async (views, options) => {
+            const entityId = await __classPrivateFieldGet$c(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
+            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$c(this, _LayoutNode_client, "f"));
+        };
+        /**
+         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.
+         *
+         * @param edge Edge whose adjacent TabStacks will be returned.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const columnOrRow = await stack.getParent();
+         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
+         * let rightStacks = await columnOrRow.getAdjacentStacks('right');
+         * let leftStacks = await columnOrRow.getAdjacentStacks('left');
+         * // or
+         * let rightStacks = await stack.getAdjacentStacks('right');
+         * let leftStacks = await stack.getAdjacentStacks('left');
+         *
+         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);
+         *
+         * ```
+         * @experimental
+         */
+        this.getAdjacentStacks = async (edge) => {
+            const adjacentStacks = await __classPrivateFieldGet$c(this, _LayoutNode_client, "f").getAdjacentStacks({
+                targetId: this.entityId,
+                edge
+            });
+            return adjacentStacks.map((stack) => LayoutNode.getEntity({
+                type: 'stack',
+                entityId: stack.entityId
+            }, __classPrivateFieldGet$c(this, _LayoutNode_client, "f")));
+        };
+        __classPrivateFieldSet$a(this, _LayoutNode_client, client, "f");
+        this.entityId = entityId;
     }
-    /**
-     * Navigates the WebContents forward one page.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function navigateForward() {
-     *     const view = await fin.View.getCurrent();
-     *     await view.navigate('https://www.google.com');
-     *     await view.navigateBack();
-     *     return await view.navigateForward();
-     * }
-     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
-     * ```js
-     * async function navigateForward() {
-     *     const win = await fin.Window.getCurrent();
-     *     await win.navigate('https://www.google.com');
-     *     await win.navigateBack();
-     *     return await win.navigateForward();
-     * }
-     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    async navigateForward() {
-        await this.wire.sendAction('navigate-window-forward', { ...this.identity });
+}
+layoutEntities.LayoutNode = LayoutNode;
+_LayoutNode_client = new WeakMap();
+/**
+ * @ignore
+ * @internal
+ * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch
+ * @param client
+ * @param controllerId
+ * @param identity
+ * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId
+ */
+LayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {
+    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');
+    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));
+    return consumer.consume({ id: controllerId });
+};
+LayoutNode.getEntity = (definition, client) => {
+    const { entityId, type } = definition;
+    switch (type) {
+        case 'column':
+        case 'row':
+            return new ColumnOrRow(client, entityId, type);
+        case 'stack':
+            return new TabStack(client, entityId);
+        default:
+            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);
     }
-    /**
-     * Stops any current navigation the WebContents is performing.
-     *
-     * @example
-     * View:
-     * ```js
-     * async function stopNavigation() {
-     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
-     *     await view.navigate('https://www.google.com');
-     *     return await view.stopNavigation();
-     * }
-     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
-     * ```
-     *
-     * Window:
+};
+/**
+ * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
+ */
+class TabStack extends LayoutNode {
+    /** @internal */
+    constructor(client, entityId) {
+        super(client, entityId);
+        /**
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _TabStack_client.set(this, void 0);
+        /**
+         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.
+         */
+        this.type = 'stack';
+        /**
+         * Retrieves a list of all views belonging to this {@link TabStack}.
+         *
+         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         * If that happens and then getViews() is called, it will return the identities in a different order than
+         * than the currently rendered tab order.
+         *
+         *
+         * @throws If the {@link TabStack} has been destroyed.
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Alternatively, you can wrap any view and get the stack from there
+         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
+         * // const stack = await viewFromSomewhere.getCurrentStack();
+         * const views = await stack.getViews();
+         * console.log(`Stack contains ${views.length} view(s)`);
+         * ```
+         * @experimental
+         */
+        this.getViews = () => __classPrivateFieldGet$c(this, _TabStack_client, "f").getStackViews(this.entityId);
+        /**
+         * Adds or creates a view in this {@link TabStack}.
+         *
+         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active
+         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
+         *
+         * @param view The identity of an existing view to add, or options to create a view.
+         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)
+         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.
+         * @throws If the view does not exist or fails to create.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Alternatively, you can wrap any view and get the stack from there
+         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
+         * // const stack = await viewFromSomewhere.getCurrentStack();
+         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
+         * console.log('Identity of the google view just added', { googleViewIdentity });
+         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)
+         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });
+         * console.log('Identity of the apple view just added', { appleViewIdentity });
+         * ```
+         * @experimental
+         */
+        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$c(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
+        /**
+         * Removes a view from this {@link TabStack}.
+         *
+         * @remarks Throws an exception if the view identity does not exist or was already destroyed.
+         *
+         * @param view - Identity of the view to remove.
+         * @throws If the view does not exist or does not belong to the stack.
+         * @throws If the {@link TabStack} has been destroyed.
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
+         *
+         * await stack.removeView(googleViewIdentity);
+         *
+         * try {
+         *     await stack.removeView(googleViewIdentity);
+         * } catch (error) {
+         *     // Tried to remove a view ('google-view') which does not belong to the stack.
+         *     console.log(error);
+         * }
+         * ```
+         */
+        this.removeView = async (view) => {
+            await __classPrivateFieldGet$c(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
+        };
+        /**
+         * Sets the active view of the {@link TabStack} without focusing it.
+         * @param view - Identity of the view to activate.
+         * @returns Promise which resolves with void once the view has been activated.
+         * @throws If the {@link TabStack} has been destroyed.
+         * @throws If the view does not exist.
+         * @example
+         * Change the active tab of a known View's TabStack:
+         * ```js
+         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });
+         * const stack = await targetView.getCurrentStack();
+         * await stack.setActiveView(targetView.identity);
+         * ```
+         *
+         * Set the current View as active within its TabStack:
+         * ```js
+         * const stack = await fin.me.getCurrentStack();
+         * await stack.setActiveView(fin.me.identity);
+         * ```
+         * @experimental
+         */
+        this.setActiveView = async (view) => {
+            await __classPrivateFieldGet$c(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
+        };
+        __classPrivateFieldSet$a(this, _TabStack_client, client, "f");
+    }
+}
+layoutEntities.TabStack = TabStack;
+_TabStack_client = new WeakMap();
+/**
+ * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.
+ */
+class ColumnOrRow extends LayoutNode {
+    /**
+     * @internal
+     */
+    constructor(client, entityId, type) {
+        super(client, entityId);
+        /**
+         * @ignore
+         * @internal
+         * ApiClient for {@link LayoutEntitiesController}
+         */
+        _ColumnOrRow_client.set(this, void 0);
+        /**
+         * Retrieves the content array of the ColumnOrRow
+         *
+         * @example
+         * ```js
+         * if (!fin.me.isView) {
+         *     throw new Error('Not running in a platform View.');
+         * }
+         *
+         * const stack = await fin.me.getCurrentStack();
+         * // Retrieves the parent ColumnOrRow
+         * const columnOrRow = await stack.getParent();
+         *
+         * // returns [TabStack]
+         * const contentArray = await columnOrRow.getContent();
+         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);
+         * ```
+         */
+        this.getContent = async () => {
+            const contentItemEntities = await __classPrivateFieldGet$c(this, _ColumnOrRow_client, "f").getContent(this.entityId);
+            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$c(this, _ColumnOrRow_client, "f")));
+        };
+        __classPrivateFieldSet$a(this, _ColumnOrRow_client, client, "f");
+        this.type = type;
+    }
+}
+layoutEntities.ColumnOrRow = ColumnOrRow;
+_ColumnOrRow_client = new WeakMap();
+
+var layout_constants = {};
+
+Object.defineProperty(layout_constants, "__esModule", { value: true });
+layout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;
+layout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';
+// TODO: eventually export this somehow
+layout_constants.DEFAULT_LAYOUT_KEY = '__default__';
+
+var main = {};
+
+Object.defineProperty(main, "__esModule", { value: true });
+main.WebContents = void 0;
+const base_1$i = base;
+class WebContents extends base_1$i.EmitterBase {
+    /**
+     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
+     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
+     */
+    constructor(wire, identity, entityType) {
+        super(wire, entityType, identity.uuid, identity.name);
+        this.identity = identity;
+        this.entityType = entityType;
+    }
+    /**
+     * Gets a base64 encoded image of all or part of the WebContents.
+     * @param options Options for the capturePage call.
+     *
+     * @example
+     *
+     * View:
      * ```js
-     * async function stopNavigation() {
-     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
-     *     await win.navigate('https://www.google.com');
-     *     return await win.stopNavigation();
+     * const view = fin.View.getCurrentSync();
+     *
+     * // PNG image of a full visible View
+     * console.log(await view.capturePage());
+     *
+     * // Low-quality JPEG image of a defined visible area of the view
+     * const options = {
+     *     area: {
+     *         height: 100,
+     *         width: 100,
+     *         x: 10,
+     *         y: 10,
+     *     },
+     *     format: 'jpg',
+     *     quality: 20
      * }
-     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
+     * console.log(await view.capturePage(options));
+     * ```
+     *
+     * Window:
+     * ```js
+     * const wnd = await fin.Window.getCurrent();
+     *
+     * // PNG image of a full visible window
+     * console.log(await wnd.capturePage());
+     *
+     * // Low-quality JPEG image of a defined visible area of the window
+     * const options = {
+     *     area: {
+     *         height: 100,
+     *         width: 100,
+     *         x: 10,
+     *         y: 10,
+     *     },
+     *     format: 'jpg',
+     *     quality: 20
+     * }
+     * console.log(await wnd.capturePage(options));
      * ```
+     *
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    stopNavigation() {
-        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);
+    capturePage(options) {
+        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);
     }
     /**
-     * Reloads the WebContents
+     * Executes Javascript on the WebContents, restricted to contents you own or contents owned by
+     * applications you have created.
+     * @param code JavaScript code to be executed on the view.
      *
      * @example
      * View:
      * ```js
-     * async function reload() {
-     * 	const view = await fin.View.getCurrent();
-     *     return await view.reload();
+     * async function executeJavaScript(code) {
+     *     const view = await fin.View.wrap({uuid: 'uuid', name: 'view name'});
+     *     return await view.executeJavaScript(code);
      * }
      *
-     * reload().then(() => {
-     * 		console.log('Reloaded view')
-     * }).catch(err => console.log(err));
+     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     * async function reloadWindow() {
-     * 		const app = await fin.Application.start({
-     * 				name: 'myApp',
-     * 				uuid: 'app-1',
-     * 				url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',
-     * 				autoShow: true
-     * 		});
-     * 		const win = await app.getWindow();
-     *     return await win.reload();
+     * async function executeJavaScript(code) {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.executeJavaScript.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.executeJavaScript(code);
      * }
      *
-     * reloadWindow().then(() => {
-     * 		console.log('Reloaded window')
-     * }).catch(err => console.log(err));
+     * executeJavaScript(`console.log('Hello, Openfin')`).then(() => console.log('Javascript excuted')).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    reload(ignoreCache = false) {
+    executeJavaScript(code) {
         return this.wire
-            .sendAction('reload-window', {
-            ignoreCache,
-            ...this.identity
-        })
-            .then(() => undefined);
+            .sendAction('execute-javascript-in-window', { ...this.identity, code })
+            .then(({ payload }) => payload.data);
     }
     /**
-     * Prints the WebContents.
-     * @param options Printer Options
+     * Returns the zoom level of the WebContents.
      *
-     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName
-     * is empty and the default settings for printing.
+     * @example
+     * View:
+     * ```js
+     * async function getZoomLevel() {
+     *     const view = await fin.View.getCurrent();
+     *     return await view.getZoomLevel();
+     * }
      *
-     * Use the CSS style `page-break-before: always;` to force print to a new page.
+     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
+     * ```
      *
-     * @example
+     * Window:
      * ```js
-     * const view = fin.View.getCurrentSync();
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.getZoomLevel.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
      *
-     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {
-     *     console.log('print call has been sent to the system');
-     * });
+     * async function getZoomLevel() {
+     *     const win = await createWin();
+     *     return await win.getZoomLevel();
+     * }
+     *
+     * getZoomLevel().then(zoomLevel => console.log(zoomLevel)).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    print(options = {}) {
-        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
+    getZoomLevel() {
+        return this.wire.sendAction('get-zoom-level', this.identity).then(({ payload }) => payload.data);
     }
     /**
-     * Find and highlight text on a page.
-     * @param searchTerm Term to find in page
-     * @param options Search options
-     *
-     * Note: By default, each subsequent call will highlight the next text that matches the search term.
-     *
-     * Returns a promise with the results for the request. By subscribing to the
-     * found-in-page event, you can get the results of this call as well.
+     * Sets the zoom level of the WebContents.
+     * @param level The zoom level
      *
      * @example
      * View:
      * ```js
-     * const view = fin.View.getCurrentSync();
-     *
-     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
-     * view.addListener('found-in-page', (event) => {
-     *     console.log(event);
-     * });
+     * async function setZoomLevel(number) {
+     *     const view = await fin.View.getCurrent();
+     *     return await view.setZoomLevel(number);
+     * }
      *
-     * // The promise also returns the results for the request
-     * view.findInPage('a').then((result) => {
-     *     console.log(result)
-     * });
+     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     * const win = fin.Window.getCurrentSync();
+     * async function createWin() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.setZoomLevel.html',
+     *         autoShow: true
+     *     });
+     *     return await app.getWindow();
+     * }
      *
-     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
-     * win.addListener('found-in-page', (event) => {
-     *     console.log(event);
-     * });
+     * async function setZoomLevel(number) {
+     *     const win = await createWin();
+     *     return await win.setZoomLevel(number);
+     * }
      *
-     * // The promise also returns the results for the request
-     * win.findInPage('a').then((result) => {
-     *     console.log(result)
-     * });
+     * setZoomLevel(4).then(() => console.log('Setting a  zoom level')).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    findInPage(searchTerm, options) {
-        return this.wire
-            .sendAction('find-in-page', { ...this.identity, searchTerm, options })
-            .then(({ payload }) => payload.data);
+    setZoomLevel(level) {
+        return this.wire.sendAction('set-zoom-level', { ...this.identity, level }).then(() => undefined);
     }
     /**
-     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:
+     * Navigates the WebContents to a specified URL.
      *
-     * * clearSelection - Clear the selection.
-     * * keepSelection - Translate the selection into a normal selection.
-     * * activateSelection - Focus and click the selection node.
+     * Note: The url must contain the protocol prefix such as http:// or https://.
+     * @param url - The URL to navigate the WebContents to.
      *
      * @example
      * View:
      * ```js
-     * const view = fin.View.getCurrentSync();
-     *
-     * view.addListener('found-in-page', (event) => {
-     *     setTimeout(() => {
-     *         view.stopFindInPage('clearSelection');
-     *     }, 5000);
-     * });
+     * async function createView() {
+     *     const me = await fin.Window.getCurrent();
+     *     return fin.View.create({
+     *         name: 'viewName',
+     *         target: me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     * }
      *
-     * view.findInPage('a').then(results => {
-     *     console.log(results);
-     * });
+     * createView()
+     *     .then(view => view.navigate('https://example.com'))
+     *     .then(() => console.log('navigation complete'))
+     *     .catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     * const win = fin.Window.getCurrentSync();
-     *
-     * win.addListener('found-in-page', (event) => {
-     *     setTimeout(() => {
-     *         win.stopFindInPage('clearSelection');
-     *     }, 5000);
-     * });
-     *
-     * win.findInPage('a').then(results => {
-     *     console.log(results);
-     * });
+     * async function navigate() {
+     *     const win = await fin.Window.getCurrent();
+     *     return await win.navigate('https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.navigate.html');
+     * }
+     * navigate().then(() => console.log('Navigate to tutorial')).catch(err => console.log(err));
      * ```
+     * @experimental
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    stopFindInPage(action) {
-        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);
+    navigate(url) {
+        return this.wire.sendAction('navigate-window', { ...this.identity, url }).then(() => undefined);
     }
     /**
-     * Returns an array with all system printers
-     * @deprecated use System.getPrinters instead
+     * Navigates the WebContents back one page.
      *
      * @example
      * View:
      * ```js
-     * const view = fin.View.getCurrentSync();
-     *
-     * view.getPrinters()
-     *     .then((printers) => {
-     *         printers.forEach((printer) => {
-     *             if (printer.isDefault) {
-     *                 console.log(printer);
-     *             }
-     *         });
-     *     })
-     *     .catch((err) => {
-     *         console.log(err);
-     *     });
+     * async function navigateBack() {
+     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
+     *     await view.navigate('https://www.google.com');
+     *     return await view.navigateBack();
+     * }
+     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     * const win = fin.Window.getCurrentSync();
-     *
-     * win.getPrinters()
-     *     .then((printers) => {
-     *         printers.forEach((printer) => {
-     *             if (printer.isDefault) {
-     *                 console.log(printer);
-     *             }
-     *         });
-     *     })
-     *     .catch((err) => {
-     *         console.log(err);
-     *     });
+     * async function navigateBack() {
+     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
+     *     await win.navigate('https://www.google.com');
+     *     return await win.navigateBack();
+     * }
+     * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    getPrinters() {
-        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);
+    navigateBack() {
+        return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);
     }
     /**
-     * Gives focus to the WebContents.
+     * Navigates the WebContents forward one page.
      *
      * @example
+     * View:
      * ```js
-     * async function focusWindow() {
-     *     const app = await fin.Application.start({
-     *         name: 'myApp',
-     *         uuid: 'app-1',
-     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',
-     *         autoShow: true
-     *     });
-     *     const win = await app.getWindow();
-     *     return await win.focus();
+     * async function navigateForward() {
+     *     const view = await fin.View.getCurrent();
+     *     await view.navigate('https://www.google.com');
+     *     await view.navigateBack();
+     *     return await view.navigateForward();
      * }
+     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
+     * ```
      *
-     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));
+     * Window:
+     * ```js
+     * async function navigateForward() {
+     *     const win = await fin.Window.getCurrent();
+     *     await win.navigate('https://www.google.com');
+     *     await win.navigateBack();
+     *     return await win.navigateForward();
+     * }
+     * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
-        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });
-    }
+    async navigateForward() {
+        await this.wire.sendAction('navigate-window-forward', { ...this.identity });
+    }
     /**
-     * Shows the Chromium Developer Tools
+     * Stops any current navigation the WebContents is performing.
      *
      * @example
      * View:
      * ```js
-     * async function showDeveloperTools() {
-     *     const view = await fin.View.getCurrent();
-     *     return view.showDeveloperTools();
+     * async function stopNavigation() {
+     *     const view = await fin.View.wrap({ name: 'testapp-view', uuid: 'testapp' });
+     *     await view.navigate('https://www.google.com');
+     *     return await view.stopNavigation();
      * }
-     *
-     * showDevelopertools()
-     * .then(() => console.log('Showing dev tools'))
-     * .catch(err => console.error(err));
+     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     * async function showDeveloperTools() {
-     *     const win = await fin.Window.getCurrent();
-     *     return win.showDeveloperTools();
+     * async function stopNavigation() {
+     *     const win = await fin.Window.wrap({ name: 'testapp', uuid: 'testapp' });
+     *     await win.navigate('https://www.google.com');
+     *     return await win.stopNavigation();
      * }
-     *
-     * showDevelopertools()
-     * .then(() => console.log('Showing dev tools'))
-     * .catch(err => console.error(err));
+     * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async showDeveloperTools() {
-        // Note this hits the system action map in core state for legacy reasons.
-        await this.wire.sendAction('show-developer-tools', this.identity);
+    stopNavigation() {
+        return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);
     }
     /**
-     * Retrieves the process information associated with a WebContents.
-     *
-     * Note: This includes any iframes associated with the WebContents
+     * Reloads the WebContents
      *
      * @example
      * View:
      * ```js
-     *     const view = await fin.View.getCurrent();
-     *     const processInfo = await view.getProcessInfo();
+     * async function reload() {
+     * 	const view = await fin.View.getCurrent();
+     *     return await view.reload();
+     * }
+     *
+     * reload().then(() => {
+     * 		console.log('Reloaded view')
+     * }).catch(err => console.log(err));
      * ```
      *
      * Window:
      * ```js
-     *     const win = await fin.Window.getCurrent();
-     *     const processInfo = await win.getProcessInfo();
+     * async function reloadWindow() {
+     * 		const app = await fin.Application.start({
+     * 				name: 'myApp',
+     * 				uuid: 'app-1',
+     * 				url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.reload.html',
+     * 				autoShow: true
+     * 		});
+     * 		const win = await app.getWindow();
+     *     return await win.reload();
+     * }
+     *
+     * reloadWindow().then(() => {
+     * 		console.log('Reloaded window')
+     * }).catch(err => console.log(err));
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async getProcessInfo() {
-        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);
-        return data;
+    reload(ignoreCache = false) {
+        return this.wire
+            .sendAction('reload-window', {
+            ignoreCache,
+            ...this.identity
+        })
+            .then(() => undefined);
     }
     /**
-     * Retrieves information on all Shared Workers.
-     *
-     * @example
-     * View:
-     * ```js
-     *     const view = await fin.View.create({
-     *         name: 'viewName',
-     *         target: fin.me.identity,
-     *         bounds: {top: 10, left: 10, width: 200, height: 200}
-     *     });
+     * Prints the WebContents.
+     * @param options Printer Options
      *
-     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
+     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName
+     * is empty and the default settings for printing.
      *
-     *     const sharedWorkers = await view.getSharedWorkers();
-     * ```
+     * Use the CSS style `page-break-before: always;` to force print to a new page.
      *
-     * Window:
+     * @example
      * ```js
-     *     const winOption = {
-     *         name:'child',
-     *         defaultWidth: 300,
-     *         defaultHeight: 300,
-     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
-     *         frame: true,
-     *         autoShow: true
-     *     };
-     *     const win = await fin.Window.create(winOption);
-     *     const sharedWorkers = await win.getSharedWorkers();
+     * const view = fin.View.getCurrentSync();
+     *
+     * view.print({ silent: false, deviceName: 'system-printer-name' }).then(() => {
+     *     console.log('print call has been sent to the system');
+     * });
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async getSharedWorkers() {
-        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);
+    print(options = {}) {
+        return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
     }
     /**
-     * Opens the developer tools for the shared worker context.
+     * Find and highlight text on a page.
+     * @param searchTerm Term to find in page
+     * @param options Search options
+     *
+     * Note: By default, each subsequent call will highlight the next text that matches the search term.
+     *
+     * Returns a promise with the results for the request. By subscribing to the
+     * found-in-page event, you can get the results of this call as well.
      *
      * @example
      * View:
      * ```js
-     *     const view = await fin.View.create({
-     *         name: 'viewName',
-     *         target: fin.me.identity,
-     *         bounds: {top: 10, left: 10, width: 200, height: 200}
-     *     });
+     * const view = fin.View.getCurrentSync();
      *
-     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
+     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
+     * view.addListener('found-in-page', (event) => {
+     *     console.log(event);
+     * });
      *
-     *     await view.inspectSharedWorker();
+     * // The promise also returns the results for the request
+     * view.findInPage('a').then((result) => {
+     *     console.log(result)
+     * });
      * ```
      *
-     * Example:
+     * Window:
      * ```js
-     *     const winOption = {
-     *         name:'child',
-     *         defaultWidth: 300,
-     *         defaultHeight: 300,
-     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
-     *         frame: true,
-     *         autoShow: true
-     *     };
-     *     const win = await fin.Window.create(winOption);
-     *     await win.inspectSharedWorker();
+     * const win = fin.Window.getCurrentSync();
+     *
+     * //By subscribing to the 'found in page' event we can get the results of each findInPage call made.
+     * win.addListener('found-in-page', (event) => {
+     *     console.log(event);
+     * });
+     *
+     * // The promise also returns the results for the request
+     * win.findInPage('a').then((result) => {
+     *     console.log(result)
+     * });
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async inspectSharedWorker() {
-        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });
+    findInPage(searchTerm, options) {
+        return this.wire
+            .sendAction('find-in-page', { ...this.identity, searchTerm, options })
+            .then(({ payload }) => payload.data);
     }
     /**
-     * Inspects the shared worker based on its ID.
-     * @param workerId - The id of the shared worker.
+     * Stop a {@link View#findInPage findInPage} call by specifying any of these actions:
+     *
+     * * clearSelection - Clear the selection.
+     * * keepSelection - Translate the selection into a normal selection.
+     * * activateSelection - Focus and click the selection node.
      *
      * @example
      * View:
      * ```js
-     *     const view = await fin.View.create({
-     *         name: 'viewName',
-     *         target: fin.me.identity,
-     *         bounds: {top: 10, left: 10, width: 200, height: 200}
-     *     });
+     * const view = fin.View.getCurrentSync();
      *
-     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
+     * view.addListener('found-in-page', (event) => {
+     *     setTimeout(() => {
+     *         view.stopFindInPage('clearSelection');
+     *     }, 5000);
+     * });
      *
-     *     const sharedWorkers = await view.getSharedWorkers();
-     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);
+     * view.findInPage('a').then(results => {
+     *     console.log(results);
+     * });
      * ```
      *
      * Window:
      * ```js
-     *     const winOption = {
-     *         name:'child',
-     *         defaultWidth: 300,
-     *         defaultHeight: 300,
-     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
-     *         frame: true,
-     *         autoShow: true
-     *     };
-     *     const win = await fin.Window.create(winOption);
-     *     const sharedWorkers = await win.getSharedWorkers();
-     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.addListener('found-in-page', (event) => {
+     *     setTimeout(() => {
+     *         win.stopFindInPage('clearSelection');
+     *     }, 5000);
+     * });
+     *
+     * win.findInPage('a').then(results => {
+     *     console.log(results);
+     * });
      * ```
      * @remarks
      * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
      * We do not expose an explicit superclass for this functionality, but it does have its own
      * {@link OpenFin.WebContentsEvents event namespace}.
      */
-    async inspectSharedWorkerById(workerId) {
-        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });
+    stopFindInPage(action) {
+        return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);
     }
     /**
-     * Opens the developer tools for the service worker context.
+     * Returns an array with all system printers
+     * @deprecated use System.getPrinters instead
      *
      * @example
      * View:
      * ```js
-     *     const view = await fin.View.create({
-     *         name: 'viewName',
-     *         target: fin.me.identity,
-     *         bounds: {top: 10, left: 10, width: 200, height: 200}
-     *     });
-     *
-     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');
+     * const view = fin.View.getCurrentSync();
      *
-     *     await view.inspectServiceWorker();
+     * view.getPrinters()
+     *     .then((printers) => {
+     *         printers.forEach((printer) => {
+     *             if (printer.isDefault) {
+     *                 console.log(printer);
+     *             }
+     *         });
+     *     })
+     *     .catch((err) => {
+     *         console.log(err);
+     *     });
      * ```
      *
      * Window:
      * ```js
-     *     const winOption = {
-     *         name:'child',
-     *         defaultWidth: 300,
-     *         defaultHeight: 300,
-     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',
-     *         frame: true,
-     *         autoShow: true
-     *     };
-     *     const win = await fin.Window.create(winOption);
-     *     await win.inspectServiceWorker();
-     * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
-     */
-    async inspectServiceWorker() {
-        await this.wire.sendAction('inspect-service-worker', { ...this.identity });
+     * const win = fin.Window.getCurrentSync();
+     *
+     * win.getPrinters()
+     *     .then((printers) => {
+     *         printers.forEach((printer) => {
+     *             if (printer.isDefault) {
+     *                 console.log(printer);
+     *             }
+     *         });
+     *     })
+     *     .catch((err) => {
+     *         console.log(err);
+     *     });
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    getPrinters() {
+        return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);
     }
     /**
-     * Shows a popup window.
-     *
-     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.
+     * Gives focus to the WebContents.
      *
-     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if
-     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller
-     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently
-     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup
-     * will be dismissed.
+     * @example
+     * ```js
+     * async function focusWindow() {
+     *     const app = await fin.Application.start({
+     *         name: 'myApp',
+     *         uuid: 'app-1',
+     *         url: 'https://cdn.openfin.co/docs/javascript/stable/tutorial-Window.focus.html',
+     *         autoShow: true
+     *     });
+     *     const win = await app.getWindow();
+     *     return await win.focus();
+     * }
      *
-     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.
+     * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
+        await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });
+    }
+    /**
+     * Shows the Chromium Developer Tools
      *
      * @example
+     * View:
+     * ```js
+     * async function showDeveloperTools() {
+     *     const view = await fin.View.getCurrent();
+     *     return view.showDeveloperTools();
+     * }
      *
-     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows
-     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures
-     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed
-     * result should the popup window lose focus.
+     * showDevelopertools()
+     * .then(() => console.log('Showing dev tools'))
+     * .catch(err => console.error(err));
+     * ```
      *
+     * Window:
      * ```js
-     * const result = await fin.me.showPopupWindow({
-     *     initialOptions: {
-     *         frame: false
-     *     },
-     *     url: '<my_popup_url>',
-     *     resultDispatchBehavior: 'close',
-     *     blurBehavior: 'close',
-     *     focus: true,
-     *     height: 300,
-     *     width: 300,
-     *     x: 0,
-     *     y: 0
-     * });
-     * ```
+     * async function showDeveloperTools() {
+     *     const win = await fin.Window.getCurrent();
+     *     return win.showDeveloperTools();
+     * }
      *
-     * Same as above but using an existing window as a popup by referencing its `name`:
+     * showDevelopertools()
+     * .then(() => console.log('Showing dev tools'))
+     * .catch(err => console.error(err));
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async showDeveloperTools() {
+        // Note this hits the system action map in core state for legacy reasons.
+        await this.wire.sendAction('show-developer-tools', this.identity);
+    }
+    /**
+     * Retrieves the process information associated with a WebContents.
      *
-     * Note: if a window with the `name` provided doesn't exist, it will be created.
+     * Note: This includes any iframes associated with the WebContents
      *
+     * @example
+     * View:
      * ```js
-     * const result = await fin.me.showPopupWindow({
-     *     initialOptions: {
-     *         frame: true
-     *     },
-     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
-     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
-     *     resultDispatchBehavior: 'close',
-     *     blurBehavior: 'close',
-     *     focus: true,
-     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'
-     *     height: 300,
-     *     width: 300,
-     *     x: 0,
-     *     y: 0
-     * });
+     *     const view = await fin.View.getCurrent();
+     *     const processInfo = await view.getProcessInfo();
      * ```
      *
-     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each
-     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is
-     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently
-     * dispatched result as `lastDispatchResult`:
-     *
+     * Window:
      * ```js
-     * const popupResultCallback = (payload) => {
-     *        if (payload.result === 'clicked') {
-     *            if (payload.data.topic === 'color-changed') {
-     *                // do something like
-     *                // setColor(payload.data.value);
-     *            }
-     *        }
-     * };
-     *
-     * await fin.me.showPopupWindow({
-     *     initialOptions: {
-     *         frame: false
-     *     },
-     *     url: '<my_popup_url>',
-     *     resultDispatchBehavior: 'none',
-     *     blurBehavior: 'close',
-     *     focus: true,
-     *     height: 300,
-     *     width: 300,
-     *     x: 0,
-     *     y: 0,
-     *     onPopupResult: popupResultCallback
-     * });
+     *     const win = await fin.Window.getCurrent();
+     *     const processInfo = await win.getProcessInfo();
      * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async getProcessInfo() {
+        const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);
+        return data;
+    }
+    /**
+     * Retrieves information on all Shared Workers.
      *
-     * Same as above but using an existing window as a popup:
-     *
+     * @example
+     * View:
      * ```js
-     * const popupResultCallback = (payload) => {
-     *        if (payload.result === 'clicked') {
-     *            if (payload.data.topic === 'color-changed') {
-     *                // do something like
-     *                // setColor(payload.data.value);
-     *            }
-     *        }
-     * };
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
      *
-     * await fin.me.showPopupWindow({
-     *     initialOptions: {
-     *         frame: false
-     *     },
-     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
-     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
-     *     resultDispatchBehavior: 'none',
-     *     blurBehavior: 'hide',
-     *     focus: true,
-     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'
-     *     height: 300,
-     *     width: 300,
-     *     x: 0,
-     *     y: 0,
-     *     onPopupResult: popupResultCallback
-     * });
-     * ```
+     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
      *
-     * Create or show a popup window that disables user movement (positioning and resizing) in the caller
-     * view's parent window by using `blurBehavior: 'modal'`:
+     *     const sharedWorkers = await view.getSharedWorkers();
+     * ```
      *
+     * Window:
      * ```js
-     * const result = await fin.me.showPopupWindow({
-     *     initialOptions: {
-     *         frame: false
-     *     },
-     *     url: '<my_popup_url>',
-     *     resultDispatchBehavior: 'close',
-     *     blurBehavior: 'modal',
-     *     focus: true,
-     *     height: 300,
-     *     width: 300,
-     *     x: 0,
-     *     y: 0
-     * });
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     const sharedWorkers = await win.getSharedWorkers();
      * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async getSharedWorkers() {
+        return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);
+    }
+    /**
+     * Opens the developer tools for the shared worker context.
      *
-     * Create a popup window as a modal:
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
      *
-     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a
-     * `modalParentIdentity` that uses the caller view's parent window identity.
+     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
      *
-     * ```js
-     * const result = await fin.me.showPopupWindow({
+     *     await view.inspectSharedWorker();
+     * ```
+     *
+     * Example:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     await win.inspectSharedWorker();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectSharedWorker() {
+        await this.wire.sendAction('inspect-shared-worker', { ...this.identity });
+    }
+    /**
+     * Inspects the shared worker based on its ID.
+     * @param workerId - The id of the shared worker.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('http://mdn.github.io/simple-shared-worker/index2.html');
+     *
+     *     const sharedWorkers = await view.getSharedWorkers();
+     *     await view.inspectSharedWorkerById(sharedWorkers[0].id);
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'http://mdn.github.io/simple-shared-worker/index2.html',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     const sharedWorkers = await win.getSharedWorkers();
+     *     await win.inspectSharedWorkerById(sharedWorkers[0].id);
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectSharedWorkerById(workerId) {
+        await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });
+    }
+    /**
+     * Opens the developer tools for the service worker context.
+     *
+     * @example
+     * View:
+     * ```js
+     *     const view = await fin.View.create({
+     *         name: 'viewName',
+     *         target: fin.me.identity,
+     *         bounds: {top: 10, left: 10, width: 200, height: 200}
+     *     });
+     *
+     *     await view.navigate('http://googlechrome.github.io/samples/service-worker/basic/index.html');
+     *
+     *     await view.inspectServiceWorker();
+     * ```
+     *
+     * Window:
+     * ```js
+     *     const winOption = {
+     *         name:'child',
+     *         defaultWidth: 300,
+     *         defaultHeight: 300,
+     *         url: 'http://googlechrome.github.io/samples/service-worker/basic/index.html',
+     *         frame: true,
+     *         autoShow: true
+     *     };
+     *     const win = await fin.Window.create(winOption);
+     *     await win.inspectServiceWorker();
+     * ```
+     * @remarks
+     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
+     * We do not expose an explicit superclass for this functionality, but it does have its own
+     * {@link OpenFin.WebContentsEvents event namespace}.
+     */
+    async inspectServiceWorker() {
+        await this.wire.sendAction('inspect-service-worker', { ...this.identity });
+    }
+    /**
+     * Shows a popup window.
+     *
+     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.
+     *
+     * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if
+     * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller
+     * view's parent window currently has a popup window open, calling `showPopupWindow` again will dismiss the currently
+     * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup
+     * will be dismissed.
+     *
+     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.
+     *
+     * @example
+     *
+     * Create and show a single-use popup window that returns a single result to the caller. `initialOptions` allows
+     * us to pass window options to the popup window that will be created. `resultDispatchBehavior: 'close'` ensures
+     * that once the popup window calls `dispatchPopupResult` it is closed. `blurBehavior: 'close'` will yield a dismissed
+     * result should the popup window lose focus.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '<my_popup_url>',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Same as above but using an existing window as a popup by referencing its `name`:
+     *
+     * Note: if a window with the `name` provided doesn't exist, it will be created.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: true
+     *     },
+     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
+     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     hideOnClose: true, // persist window on 'dismissed' result, alternatively change onResultDispatch and blurBehavior to 'hide'
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Create and show a popup window that is able to return multiple results to the caller via an `onPopupResult` callback. Each
+     * time the popup window calls `dispatchPopupResult`, the callback will be executed on the result. Once the popup window is
+     * closed or hidden, the `showPopupWindow` promise will resolve with a `dismissed` result that will include the most recently
+     * dispatched result as `lastDispatchResult`:
+     *
+     * ```js
+     * const popupResultCallback = (payload) => {
+     *        if (payload.result === 'clicked') {
+     *            if (payload.data.topic === 'color-changed') {
+     *                // do something like
+     *                // setColor(payload.data.value);
+     *            }
+     *        }
+     * };
+     *
+     * await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '<my_popup_url>',
+     *     resultDispatchBehavior: 'none',
+     *     blurBehavior: 'close',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0,
+     *     onPopupResult: popupResultCallback
+     * });
+     * ```
+     *
+     * Same as above but using an existing window as a popup:
+     *
+     * ```js
+     * const popupResultCallback = (payload) => {
+     *        if (payload.result === 'clicked') {
+     *            if (payload.data.topic === 'color-changed') {
+     *                // do something like
+     *                // setColor(payload.data.value);
+     *            }
+     *        }
+     * };
+     *
+     * await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     name: 'my-popup', // shows the 'my-popup' window if it exists, otherwise creates it
+     *     url: '<my_popup_url>', // navigates to this url if it doesn't match the location.href of the 'my-popup' window
+     *     resultDispatchBehavior: 'none',
+     *     blurBehavior: 'hide',
+     *     focus: true,
+     *     hideOnClose: true, // we can just use this or we can change blurBehavior to 'hide'
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0,
+     *     onPopupResult: popupResultCallback
+     * });
+     * ```
+     *
+     * Create or show a popup window that disables user movement (positioning and resizing) in the caller
+     * view's parent window by using `blurBehavior: 'modal'`:
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
+     *     initialOptions: {
+     *         frame: false
+     *     },
+     *     url: '<my_popup_url>',
+     *     resultDispatchBehavior: 'close',
+     *     blurBehavior: 'modal',
+     *     focus: true,
+     *     height: 300,
+     *     width: 300,
+     *     x: 0,
+     *     y: 0
+     * });
+     * ```
+     *
+     * Create a popup window as a modal:
+     *
+     * Note: The only way to ensure true modal behavior is to create the window being shown as a popup with a
+     * `modalParentIdentity` that uses the caller view's parent window identity.
+     *
+     * ```js
+     * const result = await fin.me.showPopupWindow({
      *     initialOptions: {
      *         frame: false,
      *         modalParentIdentity: fin.me.identity
@@ -8470,11 +9089,18 @@ var hasRequiredInstance;
 function requireInstance () {
 	if (hasRequiredInstance) return Instance$7;
 	hasRequiredInstance = 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 _View_providerChannelClient;
 	Object.defineProperty(Instance$7, "__esModule", { value: true });
 	Instance$7.View = void 0;
 	const transport_errors_1 = transportErrors;
 	const lazy_1 = lazy;
+	const layout_entities_1 = layoutEntities;
+	const layout_constants_1 = layout_constants;
 	const main_1 = main;
 	const window_1 = requireWindow();
 	/**
@@ -8792,7 +9418,7 @@ function requireInstance () {
 	            return ack.payload.data;
 	        };
 	        /**
-	         * Retrieves the OpenFin.Layout instance for the Window the View is attached to.
+	         * Retrieves the layout for the window the view is attached to.
 	         *
 	         * @example
 	         * ```js
@@ -8808,10 +9434,27 @@ function requireInstance () {
 	            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {
 	                // don't expose
 	            });
-	            return this.fin.Platform.Layout.getLayoutByViewIdentity(this.identity);
-	        };
-	        /**
-	         * Gets the View's options.
+	            const layoutWindow = await this.getCurrentWindow();
+	            try {
+	                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
+	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
+	                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);
+	                return this.fin.Platform.Layout.wrap(layoutIdentity);
+	            }
+	            catch (e) {
+	                const allowedErrors = [
+	                    'No action registered at target for',
+	                    'getLayoutIdentityForViewOrThrow is not a function'
+	                ];
+	                if (!allowedErrors.some((m) => e.message.includes(m))) {
+	                    throw e;
+	                }
+	                // fallback logic for missing endpoint
+	                return this.fin.Platform.Layout.wrap(layoutWindow.identity);
+	            }
+	        };
+	        /**
+	         * Gets the View's options.
 	         *
 	         * @example
 	         * ```js
@@ -8924,8 +9567,11 @@ function requireInstance () {
 	                // don't expose
 	            });
 	            try {
-	                const layout = await this.getParentLayout();
-	                return layout.getStackByViewIdentity(this.identity);
+	                const layoutWindow = await this.getCurrentWindow();
+	                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
+	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
+	                const stackDefinition = (await client.getStackByView(this.identity));
+	                return layout_entities_1.LayoutNode.getEntity(stackDefinition, client);
 	            }
 	            catch (error) {
 	                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });
@@ -9531,27 +10177,24 @@ function errorToPOJO(error) {
 }
 errors.errorToPOJO = errorToPOJO;
 
-var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __importDefault$2 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 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 = __importDefault$2(eventAggregator);
+const eventAggregator_1 = eventAggregator;
 const me_1$1 = me;
 const errors_1$1 = errors;
 class Transport extends events_1$5.EventEmitter {
@@ -9565,19 +10208,19 @@ class Transport extends events_1$5.EventEmitter {
         // Typing as unknown to avoid circular dependency, should not be used directly.
         _Transport_fin.set(this, void 0);
         this.connectSync = () => {
-            const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+            const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
             wire.connectSync();
         };
         // This function is only used in our tests.
         this.getPort = () => {
-            const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+            const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
             return wire.getPort();
         };
-        __classPrivateFieldSet$a(this, _Transport_wire, new WireType(this.onmessage.bind(this)), "f");
+        __classPrivateFieldSet$9(this, _Transport_wire, new WireType(this.onmessage.bind(this)), "f");
         this.environment = environment;
-        this.sendRaw = __classPrivateFieldGet$c(this, _Transport_wire, "f").send.bind(__classPrivateFieldGet$c(this, _Transport_wire, "f"));
+        this.sendRaw = __classPrivateFieldGet$b(this, _Transport_wire, "f").send.bind(__classPrivateFieldGet$b(this, _Transport_wire, "f"));
         this.registerMessageHandler(this.handleMessage.bind(this));
-        __classPrivateFieldGet$c(this, _Transport_wire, "f").on('disconnected', () => {
+        __classPrivateFieldGet$b(this, _Transport_wire, "f").on('disconnected', () => {
             for (const [, { handleNack }] of this.wireListeners) {
                 handleNack({ reason: 'Remote connection has closed' });
             }
@@ -9589,24 +10232,24 @@ class Transport extends events_1$5.EventEmitter {
         this.me = (0, me_1$1.getBaseMe)(entityType, uuid, name);
     }
     getFin() {
-        if (!__classPrivateFieldGet$c(this, _Transport_fin, "f")) {
+        if (!__classPrivateFieldGet$b(this, _Transport_fin, "f")) {
             throw new Error('No Fin object registered for this transport');
         }
-        return __classPrivateFieldGet$c(this, _Transport_fin, "f");
+        return __classPrivateFieldGet$b(this, _Transport_fin, "f");
     }
     registerFin(_fin) {
-        if (__classPrivateFieldGet$c(this, _Transport_fin, "f")) {
+        if (__classPrivateFieldGet$b(this, _Transport_fin, "f")) {
             throw new Error('Fin object has already been registered for this transport');
         }
-        __classPrivateFieldSet$a(this, _Transport_fin, _fin, "f");
+        __classPrivateFieldSet$9(this, _Transport_fin, _fin, "f");
     }
     shutdown() {
-        const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+        const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
         return wire.shutdown();
     }
     async connect(config) {
         if ((0, wire_1.isConfigWithReceiver)(config)) {
-            await __classPrivateFieldGet$c(this, _Transport_wire, "f").connect(config.receiver);
+            await __classPrivateFieldGet$b(this, _Transport_wire, "f").connect(config.receiver);
             return this.authorize(config);
         }
         if ((0, wire_1.isRemoteConfig)(config)) {
@@ -9622,13 +10265,13 @@ class Transport extends events_1$5.EventEmitter {
         return undefined;
     }
     async connectRemote(config) {
-        await __classPrivateFieldGet$c(this, _Transport_wire, "f").connect(new (this.environment.getWsConstructor())(config.address));
+        await __classPrivateFieldGet$b(this, _Transport_wire, "f").connect(new (this.environment.getWsConstructor())(config.address));
         return this.authorize(config);
     }
     async connectByPort(config) {
         const { address, uuid } = config;
         const reqAuthPayload = { ...config, type: 'file-token' };
-        const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+        const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
         await wire.connect(new (this.environment.getWsConstructor())(config.address));
         const requestExtAuthRet = await this.sendAction('request-external-authorization', {
             uuid,
@@ -9664,7 +10307,7 @@ class Transport extends events_1$5.EventEmitter {
                 payload,
                 messageId
             };
-            const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+            const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
             this.addWireListener(messageId, resolve, (payload) => this.nackHandler(payload, reject, callSites), uncorrelated);
             return wire.send(msg).catch(reject);
         });
@@ -9686,7 +10329,7 @@ class Transport extends events_1$5.EventEmitter {
             const resolver = (data) => {
                 resolve(data.payload);
             };
-            const wire = __classPrivateFieldGet$c(this, _Transport_wire, "f");
+            const wire = __classPrivateFieldGet$b(this, _Transport_wire, "f");
             return wire
                 .send(origData)
                 .then(() => this.addWireListener(id, resolver, (payload) => this.nackHandler(payload, reject), false))
@@ -9765,7 +10408,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.
@@ -9842,7 +10485,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,
@@ -10326,8 +10969,7 @@ class System extends base_1$d.EmitterBase {
         return this.wire.sendAction('get-rvm-info').then(({ payload }) => payload.data);
     }
     /**
-     * Retrieves general system information. If you need more detailed information about the
-     * OS and the currently logged in user, use `fin.System.getOSInfo()` instead.
+     * Retrieves system information.
      *
      * @example
      * ```js
@@ -10337,17 +10979,6 @@ class System extends base_1$d.EmitterBase {
     getHostSpecs() {
         return this.wire.sendAction('get-host-specs').then(({ payload }) => payload.data);
     }
-    /**
-     * Retrieves information about the OS and the currently logged in user.
-     *
-     * @example
-     * ```js
-     * fin.System.getOSInfo().then(specs => console.log(specs)).catch(err => console.log(err));
-     * ```
-     */
-    getOSInfo() {
-        return this.wire.sendAction('get-os-info').then(({ payload }) => payload.data);
-    }
     /**
      * Runs an executable or batch file. A path to the file must be included in options.
      * <br> A uuid may be optionally provided. If not provided, OpenFin will create a uuid for the new process.
@@ -11697,22 +12328,6 @@ class System extends base_1$d.EmitterBase {
     async setDomainSettings(domainSettings) {
         await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });
     }
-    /**
-     * Attempts to install and enable extensions for the security realm.  Users may want to call this function in response
-     * to an `extensions-install-failed` event.  Only extensions allowed by every application on the current security realm
-     * will be installed/enabled.
-     */
-    async refreshExtensions() {
-        const { payload } = await this.wire.sendAction('refresh-extensions');
-        return payload.data;
-    }
-    /**
-     * Gets the currently-installed
-     */
-    async getInstalledExtensions() {
-        const { payload } = await this.wire.sendAction('get-installed-extensions');
-        return payload.data;
-    }
 }
 system.System = System;
 
@@ -12113,12 +12728,12 @@ class ChannelBase {
 }
 channel.ChannelBase = ChannelBase;
 
-var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -12160,7 +12775,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
     static closeChannelByEndpointId(id) {
         const channel = channelClientsByEndpointId.get(id);
         if (channel) {
-            __classPrivateFieldGet$b(channel, _ChannelClient_close, "f").call(channel);
+            __classPrivateFieldGet$a(channel, _ChannelClient_close, "f").call(channel);
         }
     }
     /**
@@ -12171,7 +12786,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
         for (const channelClient of channelClientsByEndpointId.values()) {
             if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
                 channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet$b(channelClient, _ChannelClient_close, "f").call(channelClient);
+                __classPrivateFieldGet$a(channelClient, _ChannelClient_close, "f").call(channelClient);
             }
         }
     }
@@ -12186,12 +12801,12 @@ class ChannelClient extends channel_1$1.ChannelBase {
         this.processAction = (action, payload, senderIdentity) => super.processAction(action, payload, senderIdentity);
         _ChannelClient_close.set(this, () => {
             channelClientsByEndpointId.delete(this.endpointId);
-            __classPrivateFieldGet$b(this, _ChannelClient_strategy, "f").close();
+            __classPrivateFieldGet$a(this, _ChannelClient_strategy, "f").close();
         });
-        __classPrivateFieldSet$9(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
+        __classPrivateFieldSet$8(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
         this.disconnectListener = () => undefined;
         this.endpointId = routingInfo.endpointId;
-        __classPrivateFieldSet$9(this, _ChannelClient_strategy, strategy, "f");
+        __classPrivateFieldSet$8(this, _ChannelClient_strategy, strategy, "f");
         channelClientsByEndpointId.set(this.endpointId, this);
         strategy.receive(this.processAction);
     }
@@ -12199,7 +12814,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * a read-only provider identity
      */
     get providerIdentity() {
-        const protectedObj = __classPrivateFieldGet$b(this, _ChannelClient_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$a(this, _ChannelClient_protectedObj, "f");
         return protectedObj.providerIdentity;
     }
     /**
@@ -12228,8 +12843,8 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * ```
      */
     async dispatch(action, payload) {
-        if (__classPrivateFieldGet$b(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
-            return __classPrivateFieldGet$b(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
+        if (__classPrivateFieldGet$a(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet$a(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
         }
         throw new Error('The client you are trying to dispatch from is disconnected from the target provider.');
     }
@@ -12279,10 +12894,10 @@ class ChannelClient extends channel_1$1.ChannelBase {
      */
     async disconnect() {
         await this.sendDisconnectAction();
-        __classPrivateFieldGet$b(this, _ChannelClient_close, "f").call(this);
+        __classPrivateFieldGet$a(this, _ChannelClient_close, "f").call(this);
     }
     async sendDisconnectAction() {
-        const protectedObj = __classPrivateFieldGet$b(this, _ChannelClient_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$a(this, _ChannelClient_protectedObj, "f");
         await protectedObj.close();
     }
     /**
@@ -12315,13 +12930,13 @@ exhaustive.exhaustiveCheck = exhaustiveCheck;
 
 var strategy$3 = {};
 
-var __classPrivateFieldSet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -12346,7 +12961,7 @@ class ClassicStrategy {
         // connection problems occur
         _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
-            const to = __classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+            const to = __classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
             }
@@ -12358,28 +12973,28 @@ class ClassicStrategy {
             }
             delete cleanId.isLocalEndpointId;
             // grab the promise before awaiting it to save in our pending messages map
-            const p = __classPrivateFieldGet$a(this, _ClassicStrategy_wire, "f")
+            const p = __classPrivateFieldGet$9(this, _ClassicStrategy_wire, "f")
                 .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
                 payload
             });
-            __classPrivateFieldGet$a(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
+            __classPrivateFieldGet$9(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
             const raw = await p.catch((error) => {
                 throw new Error(error.message);
             }).finally(() => {
                 // clean up the pending promise
-                __classPrivateFieldGet$a(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
+                __classPrivateFieldGet$9(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
             });
             return raw.payload.data.result;
         };
         this.close = async () => {
             this.messageReceiver.removeEndpoint(this.providerIdentity.channelId, this.endpointId);
-            [...__classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
-            __classPrivateFieldSet$8(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
+            [...__classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
+            __classPrivateFieldSet$7(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
-        __classPrivateFieldSet$8(this, _ClassicStrategy_wire, wire, "f");
+        __classPrivateFieldSet$7(this, _ClassicStrategy_wire, wire, "f");
     }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
@@ -12388,20 +13003,20 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
-        const id = __classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
-        __classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
-        const pendingSet = __classPrivateFieldGet$a(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        const id = __classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+        __classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet$9(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
         pendingSet?.forEach((p) => {
             const errorMsg = `Channel connection with identity uuid: ${id?.uuid} / name: ${id?.name} / endpointId: ${endpointId} no longer connected.`;
             p.cancel(new Error(errorMsg));
         });
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
+        return __classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet$a(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
-        __classPrivateFieldGet$a(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
+        __classPrivateFieldGet$9(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet$9(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
         return (typeof payload?.endpointIdentity?.endpointId === 'string' ||
@@ -12417,12 +13032,12 @@ var strategy$2 = {};
 
 var endpoint = {};
 
-var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -12457,8 +13072,8 @@ class RTCEndpoint {
             if (this.rtc.rtcClient.connectionState !== 'connected') {
                 this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
                 this.close();
-                if (__classPrivateFieldGet$9(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$9(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$8(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$8(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             }
         };
@@ -12506,9 +13121,9 @@ class RTCEndpoint {
                 data = new TextDecoder().decode(e.data);
             }
             const { messageId, action, payload } = JSON.parse(data);
-            if (__classPrivateFieldGet$9(this, _RTCEndpoint_processAction, "f")) {
+            if (__classPrivateFieldGet$8(this, _RTCEndpoint_processAction, "f")) {
                 try {
-                    const res = await __classPrivateFieldGet$9(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
+                    const res = await __classPrivateFieldGet$8(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
                     this.rtc.channels.response.send(JSON.stringify({
                         messageId,
                         payload: res,
@@ -12542,25 +13157,25 @@ class RTCEndpoint {
             datachannel.onclose = (e) => {
                 [...this.responseMap.values()].forEach((promise) => promise.reject(new Error('RTCDataChannel closed unexpectedly, this is most commonly caused by message size. Note: RTC Channels have a message size limit of ~255kB.')));
                 this.close();
-                if (__classPrivateFieldGet$9(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$9(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$8(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$8(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             };
         });
     }
     onDisconnect(listener) {
-        if (!__classPrivateFieldGet$9(this, _RTCEndpoint_disconnectListener, "f")) {
-            __classPrivateFieldSet$7(this, _RTCEndpoint_disconnectListener, listener, "f");
+        if (!__classPrivateFieldGet$8(this, _RTCEndpoint_disconnectListener, "f")) {
+            __classPrivateFieldSet$6(this, _RTCEndpoint_disconnectListener, listener, "f");
         }
         else {
             throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
         }
     }
     receive(listener) {
-        if (__classPrivateFieldGet$9(this, _RTCEndpoint_processAction, "f")) {
+        if (__classPrivateFieldGet$8(this, _RTCEndpoint_processAction, "f")) {
             throw new Error('You have already set a listener for this RTC Endpoint.');
         }
-        __classPrivateFieldSet$7(this, _RTCEndpoint_processAction, listener, "f");
+        __classPrivateFieldSet$6(this, _RTCEndpoint_processAction, listener, "f");
     }
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
@@ -12571,12 +13186,12 @@ _RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = ne
 
 var strategy$1 = {};
 
-var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -12597,11 +13212,11 @@ class EndpointStrategy {
             return this.getEndpointById(endpointId).send(action, payload);
         };
         this.close = async () => {
-            if (__classPrivateFieldGet$8(this, _EndpointStrategy_connected, "f")) {
-                __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
-                __classPrivateFieldSet$6(this, _EndpointStrategy_endpointMap, new Map(), "f");
+            if (__classPrivateFieldGet$7(this, _EndpointStrategy_connected, "f")) {
+                __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
+                __classPrivateFieldSet$5(this, _EndpointStrategy_endpointMap, new Map(), "f");
             }
-            __classPrivateFieldSet$6(this, _EndpointStrategy_connected, false, "f");
+            __classPrivateFieldSet$5(this, _EndpointStrategy_connected, false, "f");
         };
         this.isValidEndpointPayload = validateEndpoint;
     }
@@ -12609,39 +13224,39 @@ class EndpointStrategy {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
     receive(listener) {
-        if (__classPrivateFieldGet$8(this, _EndpointStrategy_processAction, "f")) {
+        if (__classPrivateFieldGet$7(this, _EndpointStrategy_processAction, "f")) {
             throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);
         }
-        __classPrivateFieldSet$6(this, _EndpointStrategy_processAction, listener, "f");
+        __classPrivateFieldSet$5(this, _EndpointStrategy_processAction, listener, "f");
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$8(this, _EndpointStrategy_processAction, "f")));
+        __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$7(this, _EndpointStrategy_processAction, "f")));
     }
     getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
+        const endpoint = __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
         if (!endpoint) {
             throw new Error(`Client with endpoint id ${endpointId} is not connected`);
         }
         return endpoint;
     }
     get connected() {
-        return __classPrivateFieldGet$8(this, _EndpointStrategy_connected, "f");
+        return __classPrivateFieldGet$7(this, _EndpointStrategy_connected, "f");
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
+        return __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet$8(this, _EndpointStrategy_connected, "f")) {
+        if (!__classPrivateFieldGet$7(this, _EndpointStrategy_connected, "f")) {
             console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);
             return;
         }
         const clientStrat = new this.EndpointType(payload);
-        if (__classPrivateFieldGet$8(this, _EndpointStrategy_processAction, "f")) {
-            clientStrat.receive(__classPrivateFieldGet$8(this, _EndpointStrategy_processAction, "f"));
+        if (__classPrivateFieldGet$7(this, _EndpointStrategy_processAction, "f")) {
+            clientStrat.receive(__classPrivateFieldGet$7(this, _EndpointStrategy_processAction, "f"));
         }
-        __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
+        __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
     }
     async closeEndpoint(endpointId) {
-        __classPrivateFieldGet$8(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
+        __classPrivateFieldGet$7(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
     }
 }
 strategy$1.EndpointStrategy = EndpointStrategy;
@@ -12823,12 +13438,12 @@ function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {
 }
 runtimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;
 
-var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -12870,18 +13485,18 @@ class ChannelProvider extends channel_1.ChannelBase {
      * a read-only array containing all the identities of connecting clients.
      */
     get connections() {
-        return [...__classPrivateFieldGet$7(this, _ChannelProvider_connections, "f")];
+        return [...__classPrivateFieldGet$6(this, _ChannelProvider_connections, "f")];
     }
     static handleClientDisconnection(channel, payload) {
         const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
         if (removeById) {
-            __classPrivateFieldGet$7(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+            __classPrivateFieldGet$6(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
         }
         else {
             const multipleRemoves = channel.connections.filter((identity) => {
                 return identity.uuid === payload.uuid && identity.name === payload.name;
             });
-            multipleRemoves.forEach(__classPrivateFieldGet$7(channel, _ChannelProvider_removeEndpoint, "f"));
+            multipleRemoves.forEach(__classPrivateFieldGet$6(channel, _ChannelProvider_removeEndpoint, "f"));
         }
         channel.disconnectListener(payload);
     }
@@ -12898,8 +13513,8 @@ class ChannelProvider extends channel_1.ChannelBase {
         _ChannelProvider_strategy.set(this, void 0);
         _ChannelProvider_removeEndpoint.set(this, (identity) => {
             const remainingConnections = this.connections.filter((clientIdentity) => clientIdentity.endpointId !== identity.endpointId);
-            __classPrivateFieldGet$7(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
-            __classPrivateFieldSet$5(this, _ChannelProvider_connections, remainingConnections, "f");
+            __classPrivateFieldGet$6(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet$4(this, _ChannelProvider_connections, remainingConnections, "f");
         });
         // Must be bound.
         this.processAction = async (action, payload, senderIdentity) => {
@@ -12913,17 +13528,17 @@ class ChannelProvider extends channel_1.ChannelBase {
             return super.processAction(action, payload, senderIdentity);
         };
         _ChannelProvider_close.set(this, () => {
-            __classPrivateFieldGet$7(this, _ChannelProvider_strategy, "f").close();
+            __classPrivateFieldGet$6(this, _ChannelProvider_strategy, "f").close();
             const remove = ChannelProvider.removalMap.get(this);
             if (remove) {
                 remove();
             }
         });
-        __classPrivateFieldSet$5(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
+        __classPrivateFieldSet$4(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
         this.connectListener = () => undefined;
         this.disconnectListener = () => undefined;
-        __classPrivateFieldSet$5(this, _ChannelProvider_connections, [], "f");
-        __classPrivateFieldSet$5(this, _ChannelProvider_strategy, strategy, "f");
+        __classPrivateFieldSet$4(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$4(this, _ChannelProvider_strategy, strategy, "f");
         strategy.receive(this.processAction);
     }
     /**
@@ -12954,13 +13569,13 @@ class ChannelProvider extends channel_1.ChannelBase {
      */
     dispatch(to, action, payload) {
         const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);
-        if (endpointId && __classPrivateFieldGet$7(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
-            return __classPrivateFieldGet$7(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
+        if (endpointId && __classPrivateFieldGet$6(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet$6(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
         }
         return Promise.reject(new Error(`Client connection with identity uuid: ${to.uuid} / name: ${to.name} / endpointId: ${endpointId} no longer connected.`));
     }
     async processConnection(senderId, payload) {
-        __classPrivateFieldGet$7(this, _ChannelProvider_connections, "f").push(senderId);
+        __classPrivateFieldGet$6(this, _ChannelProvider_connections, "f").push(senderId);
         return this.connectListener(senderId, payload);
     }
     /**
@@ -12983,7 +13598,7 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     publish(action, payload) {
-        return this.connections.map((to) => __classPrivateFieldGet$7(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+        return this.connections.map((to) => __classPrivateFieldGet$6(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
     }
     /**
      * Register a listener that is called on every new client connection.
@@ -13057,11 +13672,11 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     async destroy() {
-        const protectedObj = __classPrivateFieldGet$7(this, _ChannelProvider_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$6(this, _ChannelProvider_protectedObj, "f");
         protectedObj.providerIdentity;
-        __classPrivateFieldSet$5(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$4(this, _ChannelProvider_connections, [], "f");
         await protectedObj.close();
-        __classPrivateFieldGet$7(this, _ChannelProvider_close, "f").call(this);
+        __classPrivateFieldGet$6(this, _ChannelProvider_close, "f").call(this);
     }
     /**
      * Returns an array with info on every Client connected to the Provider
@@ -13131,7 +13746,7 @@ class ChannelProvider extends channel_1.ChannelBase {
     getEndpointIdForOpenFinId(clientIdentity, action) {
         const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
         if (matchingConnections.length >= 2) {
-            const protectedObj = __classPrivateFieldGet$7(this, _ChannelProvider_protectedObj, "f");
+            const protectedObj = __classPrivateFieldGet$6(this, _ChannelProvider_protectedObj, "f");
             const { uuid, name } = clientIdentity;
             const providerUuid = protectedObj?.providerIdentity.uuid;
             const providerName = protectedObj?.providerIdentity.name;
@@ -13340,20 +13955,17 @@ class CombinedStrategy {
 }
 strategy.default = CombinedStrategy;
 
-var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$6 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __importDefault$1 = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 var _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;
 Object.defineProperty(connectionManager, "__esModule", { value: true });
 connectionManager.ConnectionManager = void 0;
@@ -13365,7 +13977,7 @@ const ice_manager_1 = iceManager;
 const provider_1$1 = provider;
 const message_receiver_1 = messageReceiver;
 const protocol_manager_1 = protocolManager;
-const strategy_3 = __importDefault$1(strategy);
+const strategy_3 = strategy;
 class ConnectionManager extends base_1$a.Base {
     static getProtocolOptionsFromStrings(protocols) {
         return protocols.map((protocol) => {
@@ -13395,8 +14007,8 @@ class ConnectionManager extends base_1$a.Base {
         };
         this.providerMap = new Map();
         this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);
-        __classPrivateFieldSet$4(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
-        __classPrivateFieldSet$4(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
+        __classPrivateFieldSet$3(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
+        __classPrivateFieldSet$3(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
     createProvider(options, providerIdentity) {
@@ -13407,7 +14019,7 @@ class ConnectionManager extends base_1$a.Base {
                 case 'rtc':
                     return new strategy_2.RTCStrategy();
                 case 'classic':
-                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$6(this, _ConnectionManager_messageReceiver, "f"), 
+                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$5(this, _ConnectionManager_messageReceiver, "f"), 
                     // Providers do not have an endpointId, use channelId as endpointId in the strategy.
                     providerIdentity.channelId, providerIdentity);
                 default:
@@ -13443,7 +14055,7 @@ class ConnectionManager extends base_1$a.Base {
         const supportedProtocols = await Promise.all(protocols.map(async (type) => {
             switch (type) {
                 case 'rtc': {
-                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$6(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
+                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$5(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
                     rtcPacket = { rtcClient, channels, channelsOpened };
                     return {
                         type: 'rtc',
@@ -13470,18 +14082,18 @@ class ConnectionManager extends base_1$a.Base {
             routingInfo.endpointId = this.wire.environment.getNextMessageId();
             // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
             // clients that are in the same context as the newly-connected client.
-            __classPrivateFieldGet$6(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
+            __classPrivateFieldGet$5(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
         }
         const answer = routingInfo.answer ?? {
             supportedProtocols: [{ type: 'classic', version: 1 }]
         };
         const createStrategyFromAnswer = async (protocol) => {
             if (protocol.type === 'rtc' && rtcPacket) {
-                await __classPrivateFieldGet$6(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
+                await __classPrivateFieldGet$5(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
                 return new strategy_2.RTCStrategy();
             }
             if (protocol.type === 'classic') {
-                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$6(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
+                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$5(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
             }
             return null;
         };
@@ -13549,7 +14161,7 @@ class ConnectionManager extends base_1$a.Base {
             clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
                 const answer = await accumP;
                 if (protocolToUse.type === 'rtc') {
-                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$6(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
+                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$5(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
                     answer.supportedProtocols.push({
                         type: 'rtc',
                         version: strategy_2.RTCInfo.version,
@@ -13597,13 +14209,13 @@ _ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnec
  *
  * @packageDocumentation
  */
-var __classPrivateFieldSet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -13612,7 +14224,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;
@@ -13660,11 +14272,11 @@ class Channel extends base_1$9.EmitterBase {
                     client_1.ChannelClient.handleProviderDisconnect(eventPayload);
                 }),
                 this.on('connected', (...args) => {
-                    __classPrivateFieldGet$5(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                    __classPrivateFieldGet$4(this, _Channel_internalEmitter, "f").emit('connected', ...args);
                 })
             ]).catch(() => new Error('error setting up channel connection listeners'));
         }));
-        __classPrivateFieldSet$3(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
+        __classPrivateFieldSet$2(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
     /**
      *
@@ -13739,7 +14351,7 @@ class Channel extends base_1$9.EmitterBase {
                         resolve(true);
                     }
                 };
-                __classPrivateFieldGet$5(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+                __classPrivateFieldGet$4(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
             });
             try {
                 if (retryInfo.count > 0) {
@@ -13771,7 +14383,7 @@ class Channel extends base_1$9.EmitterBase {
             finally {
                 retryInfo.count += 1;
                 // in case of other errors, remove our listener
-                __classPrivateFieldGet$5(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+                __classPrivateFieldGet$4(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
             }
         } while (shouldWait); // If we're waiting we retry the above loop
         // Should wait was false, no channel was found.
@@ -13830,12 +14442,12 @@ class Channel extends base_1$9.EmitterBase {
     async connect(channelName, options = {}) {
         // Make sure we don't connect before listeners are set up
         // This also errors if we're not in OpenFin, ensuring we don't run unnecessary code
-        await __classPrivateFieldGet$5(this, _Channel_readyToConnect, "f").getValue();
+        await __classPrivateFieldGet$4(this, _Channel_readyToConnect, "f").getValue();
         if (!channelName || typeof channelName !== 'string') {
             throw new Error('Please provide a channelName string to connect to a channel.');
         }
         const opts = { wait: true, ...this.wire.environment.getDefaultChannelOptions().connect, ...options };
-        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$5(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$4(this, _Channel_connectionManager, "f").createClientOffer(opts);
         let connectionUrl;
         if (this.fin.me.isFrame || this.fin.me.isView || this.fin.me.isWindow) {
             connectionUrl = (await this.fin.me.getInfo()).url;
@@ -13847,7 +14459,7 @@ class Channel extends base_1$9.EmitterBase {
             connectionUrl
         };
         const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
-        const strategy = await __classPrivateFieldGet$5(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const strategy = await __classPrivateFieldGet$4(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
         const channel = new client_1.ChannelClient(routingInfo, () => client_1.ChannelClient.wireClose(this.wire, routingInfo, routingInfo.endpointId), strategy);
         // It is the client's responsibility to handle endpoint disconnection to the provider.
         // If the endpoint dies, the client will force a disconnection through the core.
@@ -13916,7 +14528,7 @@ class Channel extends base_1$9.EmitterBase {
             throw new Error('Please provide a channelName to create a channel');
         }
         const { payload: { data: providerIdentity } } = await this.wire.sendAction('create-channel', { channelName });
-        const channel = __classPrivateFieldGet$5(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
+        const channel = __classPrivateFieldGet$4(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
         // TODO: fix typing (internal)
         // @ts-expect-error
         this.on('client-disconnected', (eventPayload) => {
@@ -13939,7 +14551,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;
@@ -14482,7 +15094,7 @@ var Factory$2 = {};
 
 var Instance$2 = {};
 
-var __classPrivateFieldGet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -14515,7 +15127,7 @@ class Platform extends base_1$5.EmitterBase {
             const target = identity || this.identity;
             const { uuid } = target;
             if (!clientMap.has(uuid)) {
-                const clientPromise = __classPrivateFieldGet$4(this, _Platform_connectToProvider, "f").call(this, uuid);
+                const clientPromise = __classPrivateFieldGet$3(this, _Platform_connectToProvider, "f").call(this, uuid);
                 clientMap.set(uuid, clientPromise);
             }
             // we set it above
@@ -15152,842 +15764,178 @@ class Platform extends base_1$5.EmitterBase {
      * platform.
      * This method can be called from the window itself, or from any child view. Context data is shared by all
      * entities within a window.
-     *
-     * @example
-     * Setting own context:
-     * ```js
-     * const platform = fin.Platform.getCurrentSync();
-     * const contextData = {
-     *     security: 'STOCK',
-     *     currentView: 'detailed'
-     * }
-     *
-     * await platform.setWindowContext(contextData);
-     * // Context of current window is now set to `contextData`
-     * ```
-     *
-     * Setting the context of another window or view:
-     * ```js
-     * const platform = fin.Platform.getCurrentSync();
-     * const contextData = {
-     *     security: 'STOCK',
-     *     currentView: 'detailed'
-     * }
-     *
-     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
-     * await platform.setWindowContext(contextData, windowOrViewIdentity);
-     * // Context of the target window or view is now set to `contextData`
-     * ```
-     *
-     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.
-     * This event will fire when a host window's context is updated or when the view is reparented to a new window:
-     *
-     * ```js
-     * // From a view
-     * const contextChangeHandler = ({ context }) => {
-     *     console.log('Host window\'s context has changed. New context data:', context);
-     *     // react to new context data here
-     * }
-     * await fin.me.on('host-context-changed', contextChangeHandler);
-     *
-     * const platform = await fin.Platform.getCurrentSync();
-     * const contextData = {
-     *     security: 'STOCK',
-     *     currentView: 'detailed'
-     * }
-     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
-     * ```
-     *
-     * To listen to a window's context updates, use the `context-changed` event:
-     * ```js
-     * // From a window
-     * const contextChangeHandler = ({ context }) => {
-     *     console.log('This window\'s context has changed. New context data:', context);
-     *     // react to new context data here
-     * }
-     * await fin.me.on('context-changed', contextChangeHandler);
-     *
-     * const platform = await fin.Platform.getCurrentSync();
-     * const contextData = {
-     *     security: 'STOCK',
-     *     currentView: 'detailed'
-     * }
-     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
-     * ```
-     * @experimental
-     */
-    async setWindowContext(context = {}, target) {
-        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {
-            // don't expose
-        });
-        if (!context) {
-            throw new Error('Please provide a serializable object or string to set the context.');
-        }
-        const client = await this.getClient();
-        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
-        await client.dispatch('set-window-context', {
-            context,
-            entityType,
-            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }
-        });
-    }
-    /**
-     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.
-     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.
-     * @param target - A target window or view may optionally be provided. If no target is provided, target will be
-     * the current window (if called from a Window) or the current host window (if called from a View).
-     *
-     * @remarks This method can be called from the window itself, or from any child view. Context data is shared
-     * by all entities within a window.
-     *
-     * @example
-     *
-     * Retrieving context from current window:
-     * ```js
-     * const platform = fin.Platform.getCurrentSync();
-     * const customContext = { answer: 42 };
-     * await platform.setWindowContext(customContext);
-     *
-     * const myContext = await platform.getWindowContext();
-     * console.log(myContext); // { answer: 42 }
-     * ```
-     *
-     * Retrieving the context of another window or view:
-     * ```js
-     * const platform = fin.Platform.getCurrentSync();
-     *
-     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
-     *
-     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);
-     * console.log(targetWindowContext); // context of target window
-     * ```
-     * @experimental
-     */
-    async getWindowContext(target) {
-        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {
-            // don't expose
-        });
-        const client = await this.getClient();
-        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
-        return client.dispatch('get-window-context', {
-            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },
-            entityType
-        });
-    }
-    /**
-     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire
-     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.
-     * @param winId
-     * @param options
-     *
-     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,
-     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.
-     *
-     * @example
-     *
-     * ```js
-     * // Close the current Window inside a Window context
-     * const platform = await fin.Platform.getCurrent();
-     * platform.closeWindow(fin.me.identity);
-     *
-     * // Close the Window from inside a View context
-     * const platform = await fin.Platform.getCurrent();
-     * const parentWindow = await fin.me.getCurrentWindow();
-     * platform.closeWindow(parentWindow.identity);
-     *
-     * // Close the Window and do not fire the before unload handler on Views
-     * const platform = await fin.Platform.getCurrent();
-     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });
-     * ```
-     * @experimental
-     */
-    async closeWindow(windowId, options = { skipBeforeUnload: false }) {
-        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {
-            // don't expose
-        });
-        const client = await this.getClient();
-        return client.dispatch('close-window', { windowId, options });
-    }
-}
-Instance$2.Platform = Platform;
-_Platform_connectToProvider = new WeakMap();
-
-var layout = {};
-
-var Factory$1 = {};
-
-var Instance$1 = {};
-
-var layoutEntities = {};
-
-var apiExposer$1 = {};
-
-var apiConsumer = {};
-
-Object.defineProperty(apiConsumer, "__esModule", { value: true });
-apiConsumer.ApiConsumer = void 0;
-/**
- * Consumer for apis exposed with {@see ApiExposer}.
- *
- * A strategy that matches the strategy used to expose a target API must be provided.
- */
-class ApiConsumer {
-    // eslint-disable-next-line
-    constructor(strategy) {
-        this.strategy = strategy;
-        /**
-         * Consumes an api exposed using a given transport strategy, and generates a client
-         * for easy, type safe consumption of that client.
-         * @param options Strategy specific consumption options.
-         * @returns An api client matching the given type.
-         */
-        this.consume = async (options) => {
-            const exposedProperties = await this.strategy.getExposedFunctions(options);
-            return exposedProperties.reduce((client, prop) => ({
-                ...client,
-                [prop.key]: this.strategy.createFunction(prop, options)
-            }), {});
-        };
-    }
-}
-apiConsumer.ApiConsumer = ApiConsumer;
-
-var apiExposer = {};
-
-var decorators = {};
-
-Object.defineProperty(decorators, "__esModule", { value: true });
-decorators.expose = decorators.getExposedProperties = void 0;
-const exposedProperties = Symbol('exposedProperties');
-const getExposedProperties = (target) => {
-    return target[exposedProperties] || target.prototype[exposedProperties] || [];
-};
-decorators.getExposedProperties = getExposedProperties;
-/**
- * Indicates that a class member function can be exposed using {@link ApiExposer}.
- * @param options Options specific to the strategy used in {@link ApiExposer}
- */
-// Returns any as decorator typing is weird.
-const expose = (options) => (target, key, descriptor) => {
-    target[exposedProperties] = target[exposedProperties] || [];
-    target[exposedProperties].push({ key, descriptor, options });
-};
-decorators.expose = expose;
-
-Object.defineProperty(apiExposer, "__esModule", { value: true });
-apiExposer.ApiExposer = void 0;
-const decorators_1 = decorators;
-/**
- * Exposes api services on the transport of choice.
- */
-class ApiExposer {
-    /**
-     * @param strategy The expose strategy to use to expose instances.
-     */
-    // eslint-disable-next-line
-    constructor(strategy) {
-        this.strategy = strategy;
-        /**
-         * Exposes an instance of a given api on
-         * @param instance Instance of a class which has been decorated to indicate which functions can be exposed.
-         * @param instanceOptions Transport strategy specific options to use when exposing.
-         */
-        this.exposeInstance = async (instance, instanceOptions) => {
-            const exposableProps = (0, decorators_1.getExposedProperties)(instance);
-            const exposedProps = await Promise.all(exposableProps.map(async ({ key, options }) => {
-                const customConsumptionOptions = await this.strategy.exposeFunction(instance[key].bind(instance), {
-                    key,
-                    options,
-                    meta: instanceOptions
-                });
-                return {
-                    key,
-                    options: customConsumptionOptions
-                };
-            }));
-            await this.strategy.exposeMeta(instanceOptions, exposedProps);
-        };
-    }
-    ;
-}
-apiExposer.ApiExposer = ApiExposer;
-
-var strategies = {};
-
-var openfinChannels = {};
-
-var channelsConsumer = {};
-
-Object.defineProperty(channelsConsumer, "__esModule", { value: true });
-channelsConsumer.ChannelsConsumer = void 0;
-class ChannelsConsumer {
-    // eslint-disable-next-line
-    constructor(channel) {
-        this.channel = channel;
-        this.getExposedFunctions = async (options) => {
-            const { id } = options;
-            const { props } = await this.channel.dispatch(`api-meta:${id}`);
-            return props;
-        };
-        this.createFunction = (prop) => (...args) => {
-            const { action } = prop.options;
-            return this.channel.dispatch(action, { args });
-        };
-    }
-    ;
-}
-channelsConsumer.ChannelsConsumer = ChannelsConsumer;
-
-var channelsExposer = {};
-
-Object.defineProperty(channelsExposer, "__esModule", { value: true });
-channelsExposer.ChannelsExposer = void 0;
-class ChannelsExposer {
-    // eslint-disable-next-line
-    constructor(channelProviderOrClient) {
-        this.channelProviderOrClient = channelProviderOrClient;
-        this.exposeFunction = async (target, config) => {
-            const { key, options, meta } = config;
-            const { id } = meta;
-            const action = `${id}.${options?.action || key}`;
-            await this.channelProviderOrClient.register(action, async ({ args }) => {
-                return target(...args);
-            });
-            return { action };
-        };
-        this.exposeMeta = async ({ id }, props) => {
-            const action = `api-meta:${id}`;
-            await this.channelProviderOrClient.register(action, () => ({ props }));
-        };
-    }
-}
-channelsExposer.ChannelsExposer = ChannelsExposer;
-
-(function (exports) {
-	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    var desc = Object.getOwnPropertyDescriptor(m, k);
-	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-	      desc = { enumerable: true, get: function() { return m[k]; } };
-	    }
-	    Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    o[k2] = m[k];
-	}));
-	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	__exportStar(channelsConsumer, exports);
-	__exportStar(channelsExposer, exports); 
-} (openfinChannels));
-
-(function (exports) {
-	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    var desc = Object.getOwnPropertyDescriptor(m, k);
-	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-	      desc = { enumerable: true, get: function() { return m[k]; } };
-	    }
-	    Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    o[k2] = m[k];
-	}));
-	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	__exportStar(openfinChannels, exports); 
-} (strategies));
-
-(function (exports) {
-	var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    var desc = Object.getOwnPropertyDescriptor(m, k);
-	    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-	      desc = { enumerable: true, get: function() { return m[k]; } };
-	    }
-	    Object.defineProperty(o, k2, desc);
-	}) : (function(o, m, k, k2) {
-	    if (k2 === undefined) k2 = k;
-	    o[k2] = m[k];
-	}));
-	var __exportStar = (commonjsGlobal && commonjsGlobal.__exportStar) || function(m, exports) {
-	    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-	};
-	Object.defineProperty(exports, "__esModule", { value: true });
-	__exportStar(apiConsumer, exports);
-	__exportStar(apiExposer, exports);
-	__exportStar(strategies, exports);
-	__exportStar(decorators, exports); 
-} (apiExposer$1));
-
-var channelApiRelay = {};
-
-Object.defineProperty(channelApiRelay, "__esModule", { value: true });
-channelApiRelay.createRelayedDispatch = channelApiRelay.relayChannelClientApi = void 0;
-const EXPECTED_ERRORS = [
-    'no longer connected',
-    'RTCDataChannel closed unexpectedly',
-    'The client you are trying to dispatch from is disconnected from the target provider',
-];
-// Checks possible error messages that we want to trap, client error message can originate
-// from ChannelProvider::dispatch OR ClassicStrategy::closeEndpoint OR RTCEndPoint::dataChannel::onclose
-const isDisconnectedError = (errorMsg) => {
-    return EXPECTED_ERRORS.some(e => errorMsg.includes(e));
-};
-/**
- * @internal
- * Create a channel relay for a given channel exposition, allowing a single provider to route
- * actions to the designated clients.
- *
- * Designed to be used in conjunction with @expose
- *
- * @param channelProvider The channel provider to relay the actions on.
- * @param config Determines which actions to relay. Please ensure action prefix matches the exposed api.
- */
-const relayChannelClientApi = async (channelProvider, relayId) => {
-    channelProvider.register(`relay:${relayId}`, ({ action, target, payload }) => {
-        return channelProvider.dispatch(target, action, payload);
-    });
-    await Promise.resolve();
-};
-channelApiRelay.relayChannelClientApi = relayChannelClientApi;
-const createRelayedDispatch = (client, target, relayId, relayErrorMsg) => async (action, payload) => {
-    try {
-        return await client.dispatch(`relay:${relayId}`, {
-            action,
-            payload,
-            target
-        });
-    }
-    catch (e) {
-        if (isDisconnectedError(e.message) && relayErrorMsg) {
-            throw new Error(relayErrorMsg);
-        }
-        throw e;
-    }
-};
-channelApiRelay.createRelayedDispatch = createRelayedDispatch;
-
-var __classPrivateFieldSet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    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 _LayoutNode_client, _TabStack_client, _ColumnOrRow_client;
-Object.defineProperty(layoutEntities, "__esModule", { value: true });
-layoutEntities.ColumnOrRow = layoutEntities.TabStack = layoutEntities.LayoutNode = void 0;
-const api_exposer_1 = apiExposer$1;
-const channel_api_relay_1 = channelApiRelay;
-/*
-    This file includes LayoutNode, ColumnOrRow and TabStack classes, which are all closely
-    intertwined, and share members via parent abstract class LayoutNode. To prevent circular
-    refs, we define and export all the classes here.
-*/
-/**
- * @ignore
- * @internal
- * Supplies an ApiClient for {@link LayoutEntitiesController} and helper methods
- * for the entities {@link TabStack} AND {@link ColumnOrRow} to use.
- */
-class LayoutNode {
-    /**
-     * @internal
-     * @ignore
-     */
-    constructor(client, entityId) {
-        /**
-         * @ignore
-         * @internal
-         * ApiClient for {@link LayoutEntitiesController}
-         */
-        _LayoutNode_client.set(this, void 0);
-        /**
-         * Checks if the TabStack or ColumnOrRow is the root content item
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * const isRoot = await stack.isRoot();
-         * // The TabStack is root: false
-         * console.log(`The TabStack is root: ${isRoot}`);
-         *
-         * // Retrieves the parent ColumnOrRow
-         * const parent = await stack.getParent();
-         * const parentIsRoot = await parent.isRoot();
-         * // The parent ColumnOrRow is root: true
-         * console.log(`The parent ColumnOrRow is root: ${parentIsRoot}`);
-         * ```
-         */
-        this.isRoot = () => __classPrivateFieldGet$3(this, _LayoutNode_client, "f").isRoot(this.entityId);
-        /**
-         * Checks if the TabStack or ColumnOrRow exists
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * // Retrieves the parent ColumnOrRow
-         * const columnOrRow = await stack.getParent();
-         * let exists = await stack.exists();
-         * // or
-         * let exists = await columnOrRow.exists();
-         * // The entity exists: true
-         * console.log(`The entity exists: ${exists}`);
-         * ```
-         */
-        this.exists = () => __classPrivateFieldGet$3(this, _LayoutNode_client, "f").exists(this.entityId);
-        /**
-         * Retrieves the parent of the TabStack or ColumnOrRow
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * // Retrieves the parent ColumnOrRow
-         * const columnOrRow = await stack.getParent();
-         *
-         * // undefined if entity is the root item
-         * let parent = await columnOrRow.getParent();
-         * // or
-         * let parent = await stack.getParent();
-         * ```
-         */
-        this.getParent = async () => {
-            const parent = await __classPrivateFieldGet$3(this, _LayoutNode_client, "f").getParent(this.entityId);
-            if (!parent) {
-                return undefined;
-            }
-            return LayoutNode.getEntity(parent, __classPrivateFieldGet$3(this, _LayoutNode_client, "f"));
-        };
-        /**
-         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.
-         *
-         * Known Issue: If the number of views to add overflows the tab-container, the added views will be set as active
-         * during each render, and then placed at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
-         * This means the views you pass to createAdjacentStack() may not render in the order given by the array.
-         * Until fixed, this problem can be avoided only if your window is wide enough to fit creating all the views in the tabstack.
-         *
-         * @param views The views that will populate the new TabStack.
-         * @param options Additional options that control new TabStack creation.
-         * @returns The newly-created TabStack.
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * const columnOrRow = await stack.getParent();
-         *
-         * // Create view references by supplying a 'name' and 'url'
-         * const views = [
-         *     // if 'name' is undefined, one will be generated
-         *     // if 'url' is undefined, it will default the view URL to 'about:blank'
-         *     { name: 'google-view', url: 'http://google.com/'},
-         *     { name: 'of-developers-view', url: 'http://developers.openfin.co/'},
-         * ];
-         *
-         * // Create a view beforehand to be included in the new tab stack
-         * const outsideView = await fin.View.create({
-         *     name: 'outside-bloomberg-view',
-         *     url: 'https://bloomberg.com/',
-         *     target: fin.me.identity,
-         * });
-         *
-         * // Views to add can be identities, or the reference views mentioned above
-         * const viewsToAdd = [outsideView.identity, ...views];
-         *
-         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
-         * let stackFrom = await columnOrRow.createAdjacentStack(viewsToAdd, { position: 'right' });
-         * // Or
-         * let newStack = await stack.createAdjacentStack(viewsToAdd, { position: 'right' });
-         * console.log(`A new TabStack created to the right has ${newStack.length} views in it`);
-         *
-         * ```
-         * @experimental
-         */
-        this.createAdjacentStack = async (views, options) => {
-            const entityId = await __classPrivateFieldGet$3(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
-            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$3(this, _LayoutNode_client, "f"));
-        };
-        /**
-         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.
-         *
-         * @param edge Edge whose adjacent TabStacks will be returned.
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * const columnOrRow = await stack.getParent();
-         * // Possible position inputs: 'right' | 'left' | 'top' | 'bottom'
-         * let rightStacks = await columnOrRow.getAdjacentStacks('right');
-         * let leftStacks = await columnOrRow.getAdjacentStacks('left');
-         * // or
-         * let rightStacks = await stack.getAdjacentStacks('right');
-         * let leftStacks = await stack.getAdjacentStacks('left');
-         *
-         * console.log(`The entity has ${rightStacks.length} stacks to the right, and ${leftStacks.length} stacks to the left`);
-         *
-         * ```
-         * @experimental
-         */
-        this.getAdjacentStacks = async (edge) => {
-            const adjacentStacks = await __classPrivateFieldGet$3(this, _LayoutNode_client, "f").getAdjacentStacks({
-                targetId: this.entityId,
-                edge
-            });
-            return adjacentStacks.map((stack) => LayoutNode.getEntity({
-                type: 'stack',
-                entityId: stack.entityId
-            }, __classPrivateFieldGet$3(this, _LayoutNode_client, "f")));
-        };
-        __classPrivateFieldSet$2(this, _LayoutNode_client, client, "f");
-        this.entityId = entityId;
-    }
-}
-layoutEntities.LayoutNode = LayoutNode;
-_LayoutNode_client = new WeakMap();
-/**
- * @ignore
- * @internal
- * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch
- * @param client
- * @param controllerId
- * @param identity
- * @returns a new instance of {@link LayoutEntitiesClient} with bound to the controllerId
- */
-LayoutNode.newLayoutEntitiesClient = async (client, controllerId, identity) => {
-    const dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that does not exist or has been destroyed.');
-    const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));
-    return consumer.consume({ id: controllerId });
-};
-LayoutNode.getEntity = (definition, client) => {
-    const { entityId, type } = definition;
-    switch (type) {
-        case 'column':
-        case 'row':
-            return new ColumnOrRow(client, entityId, type);
-        case 'stack':
-            return new TabStack(client, entityId);
-        default:
-            throw new Error(`Unrecognised Layout Entity encountered ('${JSON.stringify(definition)})`);
-    }
-};
-/**
- * A TabStack is used to manage the state of a stack of tabs within an OpenFin Layout.
- */
-class TabStack extends LayoutNode {
-    /** @internal */
-    constructor(client, entityId) {
-        super(client, entityId);
-        /**
-         * @internal
-         * ApiClient for {@link LayoutEntitiesController}
-         */
-        _TabStack_client.set(this, void 0);
-        /**
-         * Type of the content item. Always stack, but useful for distinguishing between a {@link TabStack} and {@link ColumnOrRow}.
-         */
-        this.type = 'stack';
-        /**
-         * Retrieves a list of all views belonging to this {@link TabStack}.
-         *
-         * Known Issue: If adding a view overflows the tab-container width, the added view will be set as active
-         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
-         * If that happens and then getViews() is called, it will return the identities in a different order than
-         * than the currently rendered tab order.
-         *
-         *
-         * @throws If the {@link TabStack} has been destroyed.
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * // Alternatively, you can wrap any view and get the stack from there
-         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
-         * // const stack = await viewFromSomewhere.getCurrentStack();
-         * const views = await stack.getViews();
-         * console.log(`Stack contains ${views.length} view(s)`);
-         * ```
-         * @experimental
-         */
-        this.getViews = () => __classPrivateFieldGet$3(this, _TabStack_client, "f").getStackViews(this.entityId);
-        /**
-         * Adds or creates a view in this {@link TabStack}.
-         *
-         * @remarks Known Issue: If adding a view overflows the tab-container, the added view will be set as active
-         * and rendered at the front of the tab-stack, while the underlying order of tabs will remain unchanged.
-         *
-         * @param view The identity of an existing view to add, or options to create a view.
-         * @param options Optional view options: index number used to insert the view into the stack at that index. Defaults to 0 (front of the stack)
-         * @returns Resolves with the {@link OpenFin.Identity identity} of the added view.
-         * @throws If the view does not exist or fails to create.
-         * @throws If the {@link TabStack} has been destroyed.
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * // Alternatively, you can wrap any view and get the stack from there
-         * // const viewFromSomewhere = fin.View.wrapSync(someView.identity);
-         * // const stack = await viewFromSomewhere.getCurrentStack();
-         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
-         * console.log('Identity of the google view just added', { googleViewIdentity });
-         * // pass in { index: number } to set the index in the stack. Here 1 means, end of the stack (defaults to 0)
-         * const appleViewIdentity = await stack.addView({ name: 'apple-view', url: 'http://apple.com/' }, { index: 1 });
-         * console.log('Identity of the apple view just added', { appleViewIdentity });
-         * ```
-         * @experimental
-         */
-        this.addView = async (view, options = { index: 0 }) => __classPrivateFieldGet$3(this, _TabStack_client, "f").addViewToStack(this.entityId, view, options);
-        /**
-         * Removes a view from this {@link TabStack}.
-         *
-         * @remarks Throws an exception if the view identity does not exist or was already destroyed.
-         *
-         * @param view - Identity of the view to remove.
-         * @throws If the view does not exist or does not belong to the stack.
-         * @throws If the {@link TabStack} has been destroyed.
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * const googleViewIdentity = await stack.addView({ name: 'google-view', url: 'http://google.com/' });
-         *
-         * await stack.removeView(googleViewIdentity);
-         *
-         * try {
-         *     await stack.removeView(googleViewIdentity);
-         * } catch (error) {
-         *     // Tried to remove a view ('google-view') which does not belong to the stack.
-         *     console.log(error);
-         * }
-         * ```
-         */
-        this.removeView = async (view) => {
-            await __classPrivateFieldGet$3(this, _TabStack_client, "f").removeViewFromStack(this.entityId, view);
-        };
-        /**
-         * Sets the active view of the {@link TabStack} without focusing it.
-         * @param view - Identity of the view to activate.
-         * @returns Promise which resolves with void once the view has been activated.
-         * @throws If the {@link TabStack} has been destroyed.
-         * @throws If the view does not exist.
-         * @example
-         * Change the active tab of a known View's TabStack:
-         * ```js
-         * const targetView = fin.View.wrapSync({ uuid: 'uuid', name: 'view-name' });
-         * const stack = await targetView.getCurrentStack();
-         * await stack.setActiveView(targetView.identity);
-         * ```
-         *
-         * Set the current View as active within its TabStack:
-         * ```js
-         * const stack = await fin.me.getCurrentStack();
-         * await stack.setActiveView(fin.me.identity);
-         * ```
-         * @experimental
-         */
-        this.setActiveView = async (view) => {
-            await __classPrivateFieldGet$3(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
-        };
-        __classPrivateFieldSet$2(this, _TabStack_client, client, "f");
+     *
+     * @example
+     * Setting own context:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     *
+     * await platform.setWindowContext(contextData);
+     * // Context of current window is now set to `contextData`
+     * ```
+     *
+     * Setting the context of another window or view:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     *
+     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
+     * await platform.setWindowContext(contextData, windowOrViewIdentity);
+     * // Context of the target window or view is now set to `contextData`
+     * ```
+     *
+     * A view can listen to changes to its host window's context by listening to the `host-context-changed` event.
+     * This event will fire when a host window's context is updated or when the view is reparented to a new window:
+     *
+     * ```js
+     * // From a view
+     * const contextChangeHandler = ({ context }) => {
+     *     console.log('Host window\'s context has changed. New context data:', context);
+     *     // react to new context data here
+     * }
+     * await fin.me.on('host-context-changed', contextChangeHandler);
+     *
+     * const platform = await fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
+     * ```
+     *
+     * To listen to a window's context updates, use the `context-changed` event:
+     * ```js
+     * // From a window
+     * const contextChangeHandler = ({ context }) => {
+     *     console.log('This window\'s context has changed. New context data:', context);
+     *     // react to new context data here
+     * }
+     * await fin.me.on('context-changed', contextChangeHandler);
+     *
+     * const platform = await fin.Platform.getCurrentSync();
+     * const contextData = {
+     *     security: 'STOCK',
+     *     currentView: 'detailed'
+     * }
+     * platform.setWindowContext(contextData) // contextChangeHandler will log the new context
+     * ```
+     * @experimental
+     */
+    async setWindowContext(context = {}, target) {
+        this.wire.sendAction('platform-set-window-context', this.identity).catch((e) => {
+            // don't expose
+        });
+        if (!context) {
+            throw new Error('Please provide a serializable object or string to set the context.');
+        }
+        const client = await this.getClient();
+        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
+        await client.dispatch('set-window-context', {
+            context,
+            entityType,
+            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name }
+        });
     }
-}
-layoutEntities.TabStack = TabStack;
-_TabStack_client = new WeakMap();
-/**
- * A ColumnOrRow is used to manage the state of Column and Rows within an OpenFin Layout.
- */
-class ColumnOrRow extends LayoutNode {
     /**
-     * @internal
+     * Get the context context of a host window that was previously set using {@link Platform#setWindowContext setWindowContext}.
+     * The context will be saved in any platform snapshots.  Returns a promise that resolves to the context.
+     * @param target - A target window or view may optionally be provided. If no target is provided, target will be
+     * the current window (if called from a Window) or the current host window (if called from a View).
+     *
+     * @remarks This method can be called from the window itself, or from any child view. Context data is shared
+     * by all entities within a window.
+     *
+     * @example
+     *
+     * Retrieving context from current window:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const customContext = { answer: 42 };
+     * await platform.setWindowContext(customContext);
+     *
+     * const myContext = await platform.getWindowContext();
+     * console.log(myContext); // { answer: 42 }
+     * ```
+     *
+     * Retrieving the context of another window or view:
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     *
+     * const windowOrViewIdentity = { uuid: fin.me.uuid, name: 'nameOfWindowOrView' };
+     *
+     * const targetWindowContext = await platform.getWindowContext(windowOrViewIdentity);
+     * console.log(targetWindowContext); // context of target window
+     * ```
+     * @experimental
      */
-    constructor(client, entityId, type) {
-        super(client, entityId);
-        /**
-         * @ignore
-         * @internal
-         * ApiClient for {@link LayoutEntitiesController}
-         */
-        _ColumnOrRow_client.set(this, void 0);
-        /**
-         * Retrieves the content array of the ColumnOrRow
-         *
-         * @example
-         * ```js
-         * if (!fin.me.isView) {
-         *     throw new Error('Not running in a platform View.');
-         * }
-         *
-         * const stack = await fin.me.getCurrentStack();
-         * // Retrieves the parent ColumnOrRow
-         * const columnOrRow = await stack.getParent();
-         *
-         * // returns [TabStack]
-         * const contentArray = await columnOrRow.getContent();
-         * console.log(`The ColumnOrRow has ${contentArray.length} item(s)`);
-         * ```
-         */
-        this.getContent = async () => {
-            const contentItemEntities = await __classPrivateFieldGet$3(this, _ColumnOrRow_client, "f").getContent(this.entityId);
-            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$3(this, _ColumnOrRow_client, "f")));
-        };
-        __classPrivateFieldSet$2(this, _ColumnOrRow_client, client, "f");
-        this.type = type;
+    async getWindowContext(target) {
+        this.wire.sendAction('platform-get-window-context', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        const { entityType } = target ? await this.fin.System.getEntityInfo(target.uuid, target.name) : this.fin.me;
+        return client.dispatch('get-window-context', {
+            target: target || { uuid: this.fin.me.uuid, name: this.fin.me.name },
+            entityType
+        });
+    }
+    /**
+     * Closes a window. If enableBeforeUnload is enabled in the Platform options, any beforeunload handler set on Views will fire
+     * This behavior can be disabled by setting skipBeforeUnload to false in the options parameter.
+     * @param winId
+     * @param options
+     *
+     * @remarks This method works by setting a `close-requested` handler on the Platform Window. If you have your own `close-requested` handler set on the Platform Window as well,
+     * it is recommended to move that logic over to the [PlatformProvider.closeWindow]{@link PlatformProvider#closeWindow} override to ensure it runs when the Window closes.
+     *
+     * @example
+     *
+     * ```js
+     * // Close the current Window inside a Window context
+     * const platform = await fin.Platform.getCurrent();
+     * platform.closeWindow(fin.me.identity);
+     *
+     * // Close the Window from inside a View context
+     * const platform = await fin.Platform.getCurrent();
+     * const parentWindow = await fin.me.getCurrentWindow();
+     * platform.closeWindow(parentWindow.identity);
+     *
+     * // Close the Window and do not fire the before unload handler on Views
+     * const platform = await fin.Platform.getCurrent();
+     * platform.closeWindow(fin.me.identity, { skipBeforeUnload: true });
+     * ```
+     * @experimental
+     */
+    async closeWindow(windowId, options = { skipBeforeUnload: false }) {
+        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        return client.dispatch('close-window', { windowId, options });
     }
 }
-layoutEntities.ColumnOrRow = ColumnOrRow;
-_ColumnOrRow_client = new WeakMap();
+Instance$2.Platform = Platform;
+_Platform_connectToProvider = new WeakMap();
 
-var layout_constants = {};
+var layout = {};
 
-Object.defineProperty(layout_constants, "__esModule", { value: true });
-layout_constants.DEFAULT_LAYOUT_KEY = layout_constants.LAYOUT_CONTROLLER_ID = void 0;
-layout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';
-// TODO: eventually export this somehow
-layout_constants.DEFAULT_LAYOUT_KEY = '__default__';
+var Factory$1 = {};
+
+var Instance$1 = {};
 
 var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var _Layout_instances, _Layout_layoutClient, _Layout_forwardLayoutAction;
+var _Layout_layoutClient;
 Object.defineProperty(Instance$1, "__esModule", { value: true });
 Instance$1.Layout = void 0;
 const lazy_1 = lazy;
@@ -16129,19 +16077,12 @@ const layout_constants_1$1 = layout_constants;
  * ```
  */
 class Layout extends base_1$4.Base {
-    /**
-     * @internal
-     */
-    static getClient(layout) {
-        return __classPrivateFieldGet$2(layout, _Layout_layoutClient, "f").getValue();
-    }
     /**
      * @internal
      */
     // eslint-disable-next-line no-shadow
     constructor(identity, wire) {
         super(wire);
-        _Layout_instances.add(this);
         /**
          * @internal
          * Lazily constructed {@link LayoutEntitiesClient} bound to this platform's client and identity
@@ -16360,71 +16301,9 @@ class Layout extends base_1$4.Base {
         const root = await client.getRoot('layoutName' in this.identity ? this.identity : undefined);
         return layout_entities_1.LayoutNode.getEntity(root, client);
     }
-    /**
-     * Retrieves the OpenFin.TabStack instance which the View belongs to.
-     *
-     * @example
-     * ```js
-     * const viewIdentity = { uuid: 'uuid', name: 'view-name' };
-     * const stack = await fin.View.wrapSync(viewIdentity).getStackByViewIdentity(viewIdentity);
-     * console.log(await stack.getViews());
-     * ```
-     */
-    async getStackByViewIdentity(identity) {
-        this.wire.sendAction('layout-get-stack-by-view').catch(() => {
-            // don't expose
-        });
-        const client = await __classPrivateFieldGet$2(this, _Layout_layoutClient, "f").getValue();
-        const stack = await client.getStackByView(identity);
-        if (!stack) {
-            throw new Error(`No stack found for view: ${identity.uuid}/${identity.name}`);
-        }
-        return layout_entities_1.LayoutNode.getEntity(stack, client);
-    }
-    /**
-     * Adds a view to the platform layout. Behaves like @link{Platform#createView} with the current layout as the target.
-     *
-     * @param viewOptions - The options for creating the view.
-     * @param options - Optional parameters for adding the view.
-     * @param options.location - The location where the view should be added.
-     * @param options.targetView - The target view to which the new view should be added.
-     * @returns A promise that resolves to an object containing the identity of the added view.
-     */
-    async addView(viewOptions, { location, targetView } = {}) {
-        this.wire.sendAction('layout-add-view').catch((e) => {
-            // don't expose
-        });
-        const { identity } = await __classPrivateFieldGet$2(this, _Layout_instances, "m", _Layout_forwardLayoutAction).call(this, 'layout-add-view', {
-            viewOptions,
-            location,
-            targetView
-        });
-        return { identity };
-    }
-    /**
-     * Closes a view by its identity. Throws an error if the view does not belong to the current layout.
-     * Behaves like @link{Platform#closeView} but only closes the view if it belongs the current layout.
-     *
-     * @param viewIdentity - The identity of the view to close.
-     * @returns A promise that resolves when the view is closed.
-     */
-    async closeView(viewIdentity) {
-        this.wire.sendAction('layout-close-view').catch((e) => {
-            // don't expose
-        });
-        await __classPrivateFieldGet$2(this, _Layout_instances, "m", _Layout_forwardLayoutAction).call(this, 'layout-close-view', { viewIdentity });
-    }
 }
 Instance$1.Layout = Layout;
-_Layout_layoutClient = new WeakMap(), _Layout_instances = new WeakSet(), _Layout_forwardLayoutAction = 
-/**
- * @internal
- * Use to type-guard actions sent to the layout via the provider.
- */
-async function _Layout_forwardLayoutAction(action, payload) {
-    const client = await this.platform.getClient();
-    return client.dispatch(action, { target: this.identity, opts: payload });
-};
+_Layout_layoutClient = new WeakMap();
 
 var __classPrivateFieldGet$1 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
@@ -16615,7 +16494,7 @@ class LayoutModule extends base_1$3.Base {
         this.wire.sendAction('layout-get-current').catch((e) => {
             // don't expose
         });
-        if (this.wire.environment.type === 'openfin' && !this.fin.me.isWindow) {
+        if (!this.fin.me.isWindow) {
             throw new Error('You are not in a Window context.  Only Windows can have a Layout.');
         }
         const { uuid, name } = this.fin.me;
@@ -16638,54 +16517,12 @@ class LayoutModule extends base_1$3.Base {
         this.wire.sendAction('layout-get-current-sync').catch((e) => {
             // don't expose
         });
-        if (this.wire.environment.type === 'openfin' && !this.fin.me.isWindow) {
+        if (!this.fin.me.isWindow) {
             throw new Error('You are not in a Window context.  Only Windows can have a Layout.');
         }
         const { uuid, name } = this.fin.me;
         return this.wrapSync({ uuid, name });
     }
-    /**
-     * Retrieves the OpenFin.Layout instance for the Window the View is attached to.
-     *
-     * @example
-     * ```js
-     * const viewIdentity = { uuid: 'uuid', name: 'view-name' };
-     * const layout = await fin.Platform.Layout.getLayoutByViewIdentity(viewIdentity);
-     * console.log(await layout.getCurrentViews());
-     * ```
-     */
-    async getLayoutByViewIdentity(viewIdentity) {
-        this.wire.sendAction('layout-get-by-view-identity').catch(() => {
-            // don't expose
-        });
-        const winIdentity = await this.wire.environment.getViewWindowIdentity(this.fin, viewIdentity);
-        let layoutWindowIdentity = winIdentity;
-        // TODO: CORE-1857 - when we tearout active layout or drag a view out of a window, the above identity includes the whole window info.
-        if (layoutWindowIdentity.identity) {
-            layoutWindowIdentity = layoutWindowIdentity.identity;
-        }
-        try {
-            const layoutWindow = this.wrapSync(layoutWindowIdentity);
-            const client = await Instance_1$2.Layout.getClient(layoutWindow);
-            const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(viewIdentity);
-            return this.wrapSync(layoutIdentity);
-        }
-        catch (e) {
-            const allowedErrors = [
-                'No action registered at target for',
-                'getLayoutIdentityForViewOrThrow is not a function'
-            ];
-            if (!allowedErrors.some((m) => e.message.includes(m))) {
-                throw e;
-            }
-            // If a view is attached to provider window, return null
-            if (layoutWindowIdentity.uuid === layoutWindowIdentity.name) {
-                throw new Error(`View identity ${JSON.stringify(viewIdentity)} is not attached to any layout in provider window ${JSON.stringify(layoutWindowIdentity)}.`);
-            }
-            // fallback logic for missing endpoint in older runtimes
-            return this.wrapSync(layoutWindowIdentity);
-        }
-    }
 }
 Factory$1.LayoutModule = LayoutModule;
 _LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {
@@ -17281,7 +17118,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();
@@ -17330,15 +17167,12 @@ Fin_1 = fin$1.Fin = Fin;
 
 var browser = {};
 
-var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(browser, "__esModule", { value: true });
 browser.remoteConnectInterop = browser.remoteConnect = getRemoteConnectionPayload_1 = browser.getRemoteConnectionPayload = void 0;
 const fin_1 = fin$1;
 const browser_1 = browser$1;
 const transport_1 = transport;
-const websocket_1 = __importDefault(websocket);
+const websocket_1 = websocket;
 async function getRemoteConnectionPayload(fin, uuid = `browser-connection-${Math.random().toString().slice(2)}`, interopProviderId = fin.me.uuid) {
     const { token } = await fin.System.registerExternalConnection(uuid);
     const { port } = await fin.System.getRuntimeInfo();