@openfin/core 39.83.3 → 39.83.5

package/out/mock.js

@@ -3,7 +3,8 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 var require$$0 = require('events');
-var require$$3 = require('lodash');
+var require$$0$1 = require('lodash/cloneDeep');
+var require$$3 = require('lodash/isEqual');
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {
@@ -241,27 +242,50 @@ Object.defineProperty(window$2, "__esModule", { value: true });
  *
  * @packageDocumentation
  */
+var __createBinding$1 = (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$1 = (commonjsGlobal && commonjsGlobal.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar$1 = (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$1(result, mod, k);
+    __setModuleDefault$1(result, mod);
+    return result;
+};
 Object.defineProperty(events, "__esModule", { value: true });
 events.WindowEvents = events.WebContentsEvents = events.ViewEvents = events.SystemEvents = events.PlatformEvents = events.GlobalHotkeyEvents = events.FrameEvents = events.ExternalApplicationEvents = events.BaseEvents = events.ApplicationEvents = void 0;
-const ApplicationEvents = application$1;
+const ApplicationEvents = __importStar$1(application$1);
 events.ApplicationEvents = ApplicationEvents;
-const BaseEvents = base$1;
+const BaseEvents = __importStar$1(base$1);
 events.BaseEvents = BaseEvents;
-const ExternalApplicationEvents = externalApplication$1;
+const ExternalApplicationEvents = __importStar$1(externalApplication$1);
 events.ExternalApplicationEvents = ExternalApplicationEvents;
-const FrameEvents = frame$1;
+const FrameEvents = __importStar$1(frame$1);
 events.FrameEvents = FrameEvents;
-const GlobalHotkeyEvents = globalHotkey$1;
+const GlobalHotkeyEvents = __importStar$1(globalHotkey$1);
 events.GlobalHotkeyEvents = GlobalHotkeyEvents;
-const PlatformEvents = platform$1;
+const PlatformEvents = __importStar$1(platform$1);
 events.PlatformEvents = PlatformEvents;
-const SystemEvents = system$1;
+const SystemEvents = __importStar$1(system$1);
 events.SystemEvents = SystemEvents;
-const ViewEvents = view$1;
+const ViewEvents = __importStar$1(view$1);
 events.ViewEvents = ViewEvents;
-const WebContentsEvents = webcontents;
+const WebContentsEvents = __importStar$1(webcontents);
 events.WebContentsEvents = WebContentsEvents;
-const WindowEvents = window$2;
+const WindowEvents = __importStar$1(window$2);
 events.WindowEvents = WindowEvents;
 
 (function (exports) {
@@ -793,7 +817,9 @@ function requireFactory$3 () {
 	     * @experimental
 	     */
 	    async wrap(identity) {
-	        this.wire.sendAction('view-wrap');
+	        this.wire.sendAction('view-wrap').catch((e) => {
+	            // we do not want to expose this error, just continue if this analytics-only call fails
+	        });
 	        const errorMsg = (0, validate_1.validateIdentity)(identity);
 	        if (errorMsg) {
 	            throw new Error(errorMsg);
@@ -930,902 +956,238 @@ class AsyncRetryableLazy {
 }
 lazy.AsyncRetryableLazy = AsyncRetryableLazy;
 
-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;
+var main = {};
 
-Object.defineProperty(apiExposer, "__esModule", { value: true });
-apiExposer.ApiExposer = void 0;
-const decorators_1 = decorators;
-/**
- * Exposes api services on the transport of choice.
- */
-class ApiExposer {
+Object.defineProperty(main, "__esModule", { value: true });
+main.WebContents = void 0;
+const base_1$j = base;
+class WebContents extends base_1$j.EmitterBase {
     /**
-     * @param strategy The expose strategy to use to expose instances.
+     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
+     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
      */
-    // 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);
-        };
+    constructor(wire, identity, entityType) {
+        super(wire, entityType, identity.uuid, identity.name);
+        this.identity = identity;
+        this.entityType = entityType;
     }
-    ;
-}
-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 });
-        };
+    /**
+     * 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}.
+     */
+    capturePage(options) {
+        return this.wire.sendAction('capture-page', { options, ...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 }));
-        };
+    /**
+     * 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);
     }
-}
-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
-        });
+    /**
+     * 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);
     }
-    catch (e) {
-        if (isDisconnectedError(e.message) && relayErrorMsg) {
-            throw new Error(relayErrorMsg);
-        }
-        throw e;
+    /**
+     * 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);
     }
-};
-channelApiRelay.createRelayedDispatch = createRelayedDispatch;
-
-var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var _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$d(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$d(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$d(this, _LayoutNode_client, "f").getParent(this.entityId);
-            if (!parent) {
-                return undefined;
-            }
-            return LayoutNode.getEntity(parent, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
-        };
-        /**
-         * Creates a new TabStack adjacent to the given TabStack or ColumnOrRow. Inputs can be new views to create, or existing views.
-         *
-         * 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$d(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
-            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f"));
-        };
-        /**
-         * Retrieves the adjacent TabStacks of the given TabStack or ColumnOrRow.
-         *
-         * @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$d(this, _LayoutNode_client, "f").getAdjacentStacks({
-                targetId: this.entityId,
-                edge
-            });
-            return adjacentStacks.map((stack) => LayoutNode.getEntity({
-                type: 'stack',
-                entityId: stack.entityId
-            }, __classPrivateFieldGet$d(this, _LayoutNode_client, "f")));
-        };
-        __classPrivateFieldSet$b(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$d(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$d(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$d(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$d(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
-        };
-        __classPrivateFieldSet$b(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$d(this, _ColumnOrRow_client, "f").getContent(this.entityId);
-            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$d(this, _ColumnOrRow_client, "f")));
-        };
-        __classPrivateFieldSet$b(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$j = base;
-class WebContents extends base_1$j.EmitterBase {
-    /**
-     * @param identity The identity of the {@link OpenFin.WebContentsEvents WebContents}.
-     * @param entityType The type of the {@link OpenFin.WebContentsEvents WebContents}.
-     */
-    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
-     * 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}.
-     */
-    capturePage(options) {
-        return this.wire.sendAction('capture-page', { options, ...this.identity }).then(({ payload }) => payload.data);
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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}.
+     * 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);
@@ -2670,18 +2032,11 @@ var hasRequiredInstance$2;
 function requireInstance$2 () {
 	if (hasRequiredInstance$2) return Instance$5;
 	hasRequiredInstance$2 = 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$5, "__esModule", { value: true });
 	Instance$5.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();
 	/**
@@ -2999,7 +2354,7 @@ function requireInstance$2 () {
 	            return ack.payload.data;
 	        };
 	        /**
-	         * Retrieves the layout for the window the view is attached to.
+	         * Retrieves the OpenFin.Layout instance for the Window the View is attached to.
 	         *
 	         * @example
 	         * ```js
@@ -3015,29 +2370,7 @@ function requireInstance$2 () {
 	            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {
 	                // don't expose
 	            });
-	            const layoutWindow = await this.getCurrentWindow();
-	            let layoutWindowIdentity = layoutWindow.identity;
-	            // 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 providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
-	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindowIdentity);
-	                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(layoutWindowIdentity);
-	            }
+	            return this.fin.Platform.Layout.getLayoutByViewIdentity(this.identity);
 	        };
 	        /**
 	         * Gets the View's options.
@@ -3153,11 +2486,8 @@ function requireInstance$2 () {
 	                // don't expose
 	            });
 	            try {
-	                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);
+	                const layout = await this.getParentLayout();
+	                return layout.getStackByViewIdentity(this.identity);
 	            }
 	            catch (error) {
 	                throw new transport_errors_1.RuntimeError({ reason: 'This view does not belong to a stack.', error });
@@ -8169,12 +7499,12 @@ class ChannelBase {
 }
 channel.ChannelBase = ChannelBase;
 
-var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$d = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
@@ -8216,7 +7546,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
     static closeChannelByEndpointId(id) {
         const channel = channelClientsByEndpointId.get(id);
         if (channel) {
-            __classPrivateFieldGet$c(channel, _ChannelClient_close, "f").call(channel);
+            __classPrivateFieldGet$d(channel, _ChannelClient_close, "f").call(channel);
         }
     }
     /**
@@ -8227,7 +7557,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
         for (const channelClient of channelClientsByEndpointId.values()) {
             if (channelClient.providerIdentity.channelId === eventPayload.channelId) {
                 channelClient.disconnectListener(eventPayload);
-                __classPrivateFieldGet$c(channelClient, _ChannelClient_close, "f").call(channelClient);
+                __classPrivateFieldGet$d(channelClient, _ChannelClient_close, "f").call(channelClient);
             }
         }
     }
@@ -8242,12 +7572,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$c(this, _ChannelClient_strategy, "f").close();
+            __classPrivateFieldGet$d(this, _ChannelClient_strategy, "f").close();
         });
-        __classPrivateFieldSet$a(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
+        __classPrivateFieldSet$b(this, _ChannelClient_protectedObj, new channel_1$1.ProtectedItems(routingInfo, close), "f");
         this.disconnectListener = () => undefined;
         this.endpointId = routingInfo.endpointId;
-        __classPrivateFieldSet$a(this, _ChannelClient_strategy, strategy, "f");
+        __classPrivateFieldSet$b(this, _ChannelClient_strategy, strategy, "f");
         channelClientsByEndpointId.set(this.endpointId, this);
         strategy.receive(this.processAction);
     }
@@ -8255,7 +7585,7 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * a read-only provider identity
      */
     get providerIdentity() {
-        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$d(this, _ChannelClient_protectedObj, "f");
         return protectedObj.providerIdentity;
     }
     /**
@@ -8284,8 +7614,8 @@ class ChannelClient extends channel_1$1.ChannelBase {
      * ```
      */
     async dispatch(action, payload) {
-        if (__classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
-            return __classPrivateFieldGet$c(this, _ChannelClient_strategy, "f").send(this.providerIdentity.channelId, action, payload);
+        if (__classPrivateFieldGet$d(this, _ChannelClient_strategy, "f").isEndpointConnected(this.providerIdentity.channelId)) {
+            return __classPrivateFieldGet$d(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.');
     }
@@ -8335,10 +7665,10 @@ class ChannelClient extends channel_1$1.ChannelBase {
      */
     async disconnect() {
         await this.sendDisconnectAction();
-        __classPrivateFieldGet$c(this, _ChannelClient_close, "f").call(this);
+        __classPrivateFieldGet$d(this, _ChannelClient_close, "f").call(this);
     }
     async sendDisconnectAction() {
-        const protectedObj = __classPrivateFieldGet$c(this, _ChannelClient_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$d(this, _ChannelClient_protectedObj, "f");
         await protectedObj.close();
     }
     /**
@@ -8371,13 +7701,13 @@ exhaustive.exhaustiveCheck = exhaustiveCheck;
 
 var strategy$3 = {};
 
-var __classPrivateFieldSet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$a = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$b = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$c = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
@@ -8402,7 +7732,7 @@ class ClassicStrategy {
         // connection problems occur
         _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
-            const to = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+            const to = __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
             }
@@ -8414,28 +7744,28 @@ class ClassicStrategy {
             }
             delete cleanId.isLocalEndpointId;
             // grab the promise before awaiting it to save in our pending messages map
-            const p = __classPrivateFieldGet$b(this, _ClassicStrategy_wire, "f")
+            const p = __classPrivateFieldGet$c(this, _ClassicStrategy_wire, "f")
                 .sendAction('send-channel-message', {
                 ...cleanId,
                 providerIdentity: this.providerIdentity,
                 action,
                 payload
             });
-            __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
+            __classPrivateFieldGet$c(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$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
+                __classPrivateFieldGet$c(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$b(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
-            __classPrivateFieldSet$9(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
+            [...__classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").keys()].forEach((id) => this.closeEndpoint(id));
+            __classPrivateFieldSet$a(this, _ClassicStrategy_endpointIdentityMap, new Map(), "f");
         };
-        __classPrivateFieldSet$9(this, _ClassicStrategy_wire, wire, "f");
+        __classPrivateFieldSet$a(this, _ClassicStrategy_wire, wire, "f");
     }
     onEndpointDisconnect(endpointId, listener) {
         // Never fires for 'classic'.
@@ -8444,20 +7774,20 @@ class ClassicStrategy {
         this.messageReceiver.addEndpoint(listener, this.providerIdentity.channelId, this.endpointId);
     }
     async closeEndpoint(endpointId) {
-        const id = __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
-        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
-        const pendingSet = __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
+        const id = __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
+        __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").delete(endpointId);
+        const pendingSet = __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId);
         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$b(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
+        return __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        __classPrivateFieldGet$b(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
-        __classPrivateFieldGet$b(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
+        __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").set(endpointId, payload.endpointIdentity);
+        __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
         return (typeof payload?.endpointIdentity?.endpointId === 'string' ||
@@ -8488,12 +7818,12 @@ function errorToPOJO(error) {
 }
 errors.errorToPOJO = errorToPOJO;
 
-var __classPrivateFieldGet$a = (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 __classPrivateFieldSet$8 = (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");
@@ -8528,8 +7858,8 @@ class RTCEndpoint {
             if (this.rtc.rtcClient.connectionState !== 'connected') {
                 this.rtc.rtcClient.removeEventListener('connectionstatechange', this.connectionStateChangeHandler);
                 this.close();
-                if (__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             }
         };
@@ -8577,9 +7907,9 @@ class RTCEndpoint {
                 data = new TextDecoder().decode(e.data);
             }
             const { messageId, action, payload } = JSON.parse(data);
-            if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
+            if (__classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f")) {
                 try {
-                    const res = await __classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
+                    const res = await __classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f").call(this, action, payload, endpointIdentity);
                     this.rtc.channels.response.send(JSON.stringify({
                         messageId,
                         payload: res,
@@ -8613,25 +7943,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$a(this, _RTCEndpoint_disconnectListener, "f")) {
-                    __classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f").call(this);
+                if (__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
+                    __classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f").call(this);
                 }
             };
         });
     }
     onDisconnect(listener) {
-        if (!__classPrivateFieldGet$a(this, _RTCEndpoint_disconnectListener, "f")) {
-            __classPrivateFieldSet$8(this, _RTCEndpoint_disconnectListener, listener, "f");
+        if (!__classPrivateFieldGet$b(this, _RTCEndpoint_disconnectListener, "f")) {
+            __classPrivateFieldSet$9(this, _RTCEndpoint_disconnectListener, listener, "f");
         }
         else {
             throw new Error('RTCEndpoint disconnectListener cannot be set twice.');
         }
     }
     receive(listener) {
-        if (__classPrivateFieldGet$a(this, _RTCEndpoint_processAction, "f")) {
+        if (__classPrivateFieldGet$b(this, _RTCEndpoint_processAction, "f")) {
             throw new Error('You have already set a listener for this RTC Endpoint.');
         }
-        __classPrivateFieldSet$8(this, _RTCEndpoint_processAction, listener, "f");
+        __classPrivateFieldSet$9(this, _RTCEndpoint_processAction, listener, "f");
     }
     get connected() {
         return this.rtc.rtcClient.connectionState === 'connected';
@@ -8642,12 +7972,12 @@ _RTCEndpoint_processAction = new WeakMap(), _RTCEndpoint_disconnectListener = ne
 
 var strategy$1 = {};
 
-var __classPrivateFieldGet$9 = (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$7 = (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");
@@ -8668,11 +7998,11 @@ class EndpointStrategy {
             return this.getEndpointById(endpointId).send(action, payload);
         };
         this.close = async () => {
-            if (__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
-                __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
-                __classPrivateFieldSet$7(this, _EndpointStrategy_endpointMap, new Map(), "f");
+            if (__classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f")) {
+                __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.close());
+                __classPrivateFieldSet$8(this, _EndpointStrategy_endpointMap, new Map(), "f");
             }
-            __classPrivateFieldSet$7(this, _EndpointStrategy_connected, false, "f");
+            __classPrivateFieldSet$8(this, _EndpointStrategy_connected, false, "f");
         };
         this.isValidEndpointPayload = validateEndpoint;
     }
@@ -8680,39 +8010,39 @@ class EndpointStrategy {
         this.getEndpointById(endpointId).onDisconnect(listener);
     }
     receive(listener) {
-        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
+        if (__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")) {
             throw new Error(`You have already set a listener for this ${this.StrategyName} Strategy`);
         }
-        __classPrivateFieldSet$7(this, _EndpointStrategy_processAction, listener, "f");
+        __classPrivateFieldSet$8(this, _EndpointStrategy_processAction, listener, "f");
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")));
+        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").forEach((endpoint) => endpoint.receive(__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")));
     }
     getEndpointById(endpointId) {
-        const endpoint = __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").get(endpointId);
+        const endpoint = __classPrivateFieldGet$a(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$9(this, _EndpointStrategy_connected, "f");
+        return __classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f");
     }
     isEndpointConnected(endpointId) {
-        return __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
+        return __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").has(endpointId);
     }
     addEndpoint(endpointId, payload) {
-        if (!__classPrivateFieldGet$9(this, _EndpointStrategy_connected, "f")) {
+        if (!__classPrivateFieldGet$a(this, _EndpointStrategy_connected, "f")) {
             console.warn(`Adding endpoint to disconnected ${this.StrategyName} Strategy`);
             return;
         }
         const clientStrat = new this.EndpointType(payload);
-        if (__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f")) {
-            clientStrat.receive(__classPrivateFieldGet$9(this, _EndpointStrategy_processAction, "f"));
+        if (__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f")) {
+            clientStrat.receive(__classPrivateFieldGet$a(this, _EndpointStrategy_processAction, "f"));
         }
-        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
+        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").set(endpointId, clientStrat);
     }
     async closeEndpoint(endpointId) {
-        __classPrivateFieldGet$9(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
+        __classPrivateFieldGet$a(this, _EndpointStrategy_endpointMap, "f").delete(endpointId);
     }
 }
 strategy$1.EndpointStrategy = EndpointStrategy;
@@ -8894,12 +8224,12 @@ function runtimeUuidMeetsMinimumRuntimeVersion(runtimeUuid, minVersion) {
 }
 runtimeVersioning.runtimeUuidMeetsMinimumRuntimeVersion = runtimeUuidMeetsMinimumRuntimeVersion;
 
-var __classPrivateFieldGet$8 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$9 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
-var __classPrivateFieldSet$6 = (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");
@@ -8941,18 +8271,18 @@ class ChannelProvider extends channel_1.ChannelBase {
      * a read-only array containing all the identities of connecting clients.
      */
     get connections() {
-        return [...__classPrivateFieldGet$8(this, _ChannelProvider_connections, "f")];
+        return [...__classPrivateFieldGet$9(this, _ChannelProvider_connections, "f")];
     }
     static handleClientDisconnection(channel, payload) {
         const removeById = channel.connections.find((identity) => identity.endpointId === payload.endpointId);
         if (removeById) {
-            __classPrivateFieldGet$8(channel, _ChannelProvider_removeEndpoint, "f").call(channel, removeById);
+            __classPrivateFieldGet$9(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$8(channel, _ChannelProvider_removeEndpoint, "f"));
+            multipleRemoves.forEach(__classPrivateFieldGet$9(channel, _ChannelProvider_removeEndpoint, "f"));
         }
         channel.disconnectListener(payload);
     }
@@ -8969,8 +8299,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$8(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
-            __classPrivateFieldSet$6(this, _ChannelProvider_connections, remainingConnections, "f");
+            __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").closeEndpoint(identity.endpointId);
+            __classPrivateFieldSet$7(this, _ChannelProvider_connections, remainingConnections, "f");
         });
         // Must be bound.
         this.processAction = async (action, payload, senderIdentity) => {
@@ -8984,17 +8314,17 @@ class ChannelProvider extends channel_1.ChannelBase {
             return super.processAction(action, payload, senderIdentity);
         };
         _ChannelProvider_close.set(this, () => {
-            __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").close();
+            __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").close();
             const remove = ChannelProvider.removalMap.get(this);
             if (remove) {
                 remove();
             }
         });
-        __classPrivateFieldSet$6(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
+        __classPrivateFieldSet$7(this, _ChannelProvider_protectedObj, new channel_1.ProtectedItems(providerIdentity, close), "f");
         this.connectListener = () => undefined;
         this.disconnectListener = () => undefined;
-        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
-        __classPrivateFieldSet$6(this, _ChannelProvider_strategy, strategy, "f");
+        __classPrivateFieldSet$7(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$7(this, _ChannelProvider_strategy, strategy, "f");
         strategy.receive(this.processAction);
     }
     /**
@@ -9025,13 +8355,13 @@ class ChannelProvider extends channel_1.ChannelBase {
      */
     dispatch(to, action, payload) {
         const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);
-        if (endpointId && __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
-            return __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
+        if (endpointId && __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
+            return __classPrivateFieldGet$9(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$8(this, _ChannelProvider_connections, "f").push(senderId);
+        __classPrivateFieldGet$9(this, _ChannelProvider_connections, "f").push(senderId);
         return this.connectListener(senderId, payload);
     }
     /**
@@ -9054,7 +8384,7 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     publish(action, payload) {
-        return this.connections.map((to) => __classPrivateFieldGet$8(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
+        return this.connections.map((to) => __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").send(to.endpointId, action, payload));
     }
     /**
      * Register a listener that is called on every new client connection.
@@ -9128,11 +8458,11 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     async destroy() {
-        const protectedObj = __classPrivateFieldGet$8(this, _ChannelProvider_protectedObj, "f");
+        const protectedObj = __classPrivateFieldGet$9(this, _ChannelProvider_protectedObj, "f");
         protectedObj.providerIdentity;
-        __classPrivateFieldSet$6(this, _ChannelProvider_connections, [], "f");
+        __classPrivateFieldSet$7(this, _ChannelProvider_connections, [], "f");
         await protectedObj.close();
-        __classPrivateFieldGet$8(this, _ChannelProvider_close, "f").call(this);
+        __classPrivateFieldGet$9(this, _ChannelProvider_close, "f").call(this);
     }
     /**
      * Returns an array with info on every Client connected to the Provider
@@ -9202,7 +8532,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$8(this, _ChannelProvider_protectedObj, "f");
+            const protectedObj = __classPrivateFieldGet$9(this, _ChannelProvider_protectedObj, "f");
             const { uuid, name } = clientIdentity;
             const providerUuid = protectedObj?.providerIdentity.uuid;
             const providerName = protectedObj?.providerIdentity.name;
@@ -9411,17 +8741,20 @@ class CombinedStrategy {
 }
 strategy.default = CombinedStrategy;
 
-var __classPrivateFieldSet$5 = (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");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$7 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+var __classPrivateFieldGet$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 __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;
@@ -9433,7 +8766,7 @@ const ice_manager_1 = iceManager;
 const provider_1$1 = provider;
 const message_receiver_1 = messageReceiver;
 const protocol_manager_1 = protocolManager;
-const strategy_3 = strategy;
+const strategy_3 = __importDefault$1(strategy);
 class ConnectionManager extends base_1$f.Base {
     static getProtocolOptionsFromStrings(protocols) {
         return protocols.map((protocol) => {
@@ -9463,8 +8796,8 @@ class ConnectionManager extends base_1$f.Base {
         };
         this.providerMap = new Map();
         this.protocolManager = new protocol_manager_1.ProtocolManager(this.wire.environment.type === 'node' ? ['classic'] : ['rtc', 'classic']);
-        __classPrivateFieldSet$5(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
-        __classPrivateFieldSet$5(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
+        __classPrivateFieldSet$6(this, _ConnectionManager_messageReceiver, new message_receiver_1.MessageReceiver(wire), "f");
+        __classPrivateFieldSet$6(this, _ConnectionManager_rtcConnectionManager, new ice_manager_1.RTCICEManager(wire), "f");
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
     createProvider(options, providerIdentity) {
@@ -9475,7 +8808,7 @@ class ConnectionManager extends base_1$f.Base {
                 case 'rtc':
                     return new strategy_2.RTCStrategy();
                 case 'classic':
-                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$7(this, _ConnectionManager_messageReceiver, "f"), 
+                    return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f"), 
                     // Providers do not have an endpointId, use channelId as endpointId in the strategy.
                     providerIdentity.channelId, providerIdentity);
                 default:
@@ -9511,7 +8844,7 @@ class ConnectionManager extends base_1$f.Base {
         const supportedProtocols = await Promise.all(protocols.map(async (type) => {
             switch (type) {
                 case 'rtc': {
-                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
+                    const { rtcClient, channels, offer, rtcConnectionId, channelsOpened } = await __classPrivateFieldGet$8(this, _ConnectionManager_rtcConnectionManager, "f").startClientOffer();
                     rtcPacket = { rtcClient, channels, channelsOpened };
                     return {
                         type: 'rtc',
@@ -9538,18 +8871,18 @@ class ConnectionManager extends base_1$f.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$7(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
+            __classPrivateFieldGet$8(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$7(this, _ConnectionManager_rtcConnectionManager, "f").finishClientOffer(rtcPacket.rtcClient, protocol.payload.answer, rtcPacket.channelsOpened);
+                await __classPrivateFieldGet$8(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$7(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
+                return new strategy_1.ClassicStrategy(this.wire, __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f"), routingInfo.endpointId, routingInfo);
             }
             return null;
         };
@@ -9617,7 +8950,7 @@ class ConnectionManager extends base_1$f.Base {
             clientAnswer = await overlappingProtocols.reduce(async (accumP, protocolToUse) => {
                 const answer = await accumP;
                 if (protocolToUse.type === 'rtc') {
-                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$7(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
+                    const { answer: rtcAnswer, rtcClient, channels } = await __classPrivateFieldGet$8(this, _ConnectionManager_rtcConnectionManager, "f").createProviderAnswer(protocolToUse.payload.rtcConnectionId, protocolToUse.payload.offer);
                     answer.supportedProtocols.push({
                         type: 'rtc',
                         version: strategy_2.RTCInfo.version,
@@ -9665,13 +8998,13 @@ _ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnec
  *
  * @packageDocumentation
  */
-var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+var __classPrivateFieldSet$5 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
     if (kind === "m") throw new TypeError("Private method is not writable");
     if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
     if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
     return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
 };
-var __classPrivateFieldGet$6 = (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);
@@ -9728,11 +9061,11 @@ class Channel extends base_1$e.EmitterBase {
                     client_1.ChannelClient.handleProviderDisconnect(eventPayload);
                 }),
                 this.on('connected', (...args) => {
-                    __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").emit('connected', ...args);
+                    __classPrivateFieldGet$7(this, _Channel_internalEmitter, "f").emit('connected', ...args);
                 })
             ]).catch(() => new Error('error setting up channel connection listeners'));
         }));
-        __classPrivateFieldSet$4(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
+        __classPrivateFieldSet$5(this, _Channel_connectionManager, new connection_manager_1.ConnectionManager(wire), "f");
     }
     /**
      *
@@ -9807,7 +9140,7 @@ class Channel extends base_1$e.EmitterBase {
                         resolve(true);
                     }
                 };
-                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
+                __classPrivateFieldGet$7(this, _Channel_internalEmitter, "f").on('connected', connectedListener);
             });
             try {
                 if (retryInfo.count > 0) {
@@ -9839,7 +9172,7 @@ class Channel extends base_1$e.EmitterBase {
             finally {
                 retryInfo.count += 1;
                 // in case of other errors, remove our listener
-                __classPrivateFieldGet$6(this, _Channel_internalEmitter, "f").removeListener('connected', connectedListener);
+                __classPrivateFieldGet$7(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.
@@ -9898,12 +9231,12 @@ class Channel extends base_1$e.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$6(this, _Channel_readyToConnect, "f").getValue();
+        await __classPrivateFieldGet$7(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$6(this, _Channel_connectionManager, "f").createClientOffer(opts);
+        const { offer, rtc: rtcPacket } = await __classPrivateFieldGet$7(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;
@@ -9915,7 +9248,7 @@ class Channel extends base_1$e.EmitterBase {
             connectionUrl
         };
         const routingInfo = await this.safeConnect(channelName, opts.wait, connectPayload);
-        const strategy = await __classPrivateFieldGet$6(this, _Channel_connectionManager, "f").createClientStrategy(rtcPacket, routingInfo);
+        const strategy = await __classPrivateFieldGet$7(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.
@@ -9984,7 +9317,7 @@ class Channel extends base_1$e.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$6(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
+        const channel = __classPrivateFieldGet$7(this, _Channel_connectionManager, "f").createProvider(options, providerIdentity);
         // TODO: fix typing (internal)
         // @ts-expect-error
         this.on('client-disconnected', (eventPayload) => {
@@ -10875,7 +10208,7 @@ var Factory$3 = {};
 
 var Instance$2 = {};
 
-var __classPrivateFieldGet$5 = (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);
@@ -10908,7 +10241,7 @@ class Platform extends base_1$6.EmitterBase {
             const target = identity || this.identity;
             const { uuid } = target;
             if (!clientMap.has(uuid)) {
-                const clientPromise = __classPrivateFieldGet$5(this, _Platform_connectToProvider, "f").call(this, uuid);
+                const clientPromise = __classPrivateFieldGet$6(this, _Platform_connectToProvider, "f").call(this, uuid);
                 clientMap.set(uuid, clientPromise);
             }
             // we set it above
@@ -11429,316 +10762,980 @@ class Platform extends base_1$6.EmitterBase {
      *     });
      * }
      *
-     * const win = await createWindowWithTwoViews();
-     * // ... you will now see a new window with two views in it
+     * const win = await createWindowWithTwoViews();
+     * // ... you will now see a new window with two views in it
+     *
+     * // we take a snapshot of the current state of the app, before changing it
+     * const snapshotOfInitialAppState = await platform.getSnapshot();
+     *
+     * // now let's change the state of the app:
+     * await addViewToWindow(win.identity);
+     * // ... the window now has three views in it
+     *
+     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });
+     * // ... the window will revert to previous state, with just two views
+     *
+     * ```
+     */
+    async applySnapshot(requestedSnapshot, options) {
+        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {
+            // don't expose
+        });
+        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';
+        let snapshot;
+        if (typeof requestedSnapshot === 'string') {
+            // Fetch and parse snapshot
+            try {
+                const response = await this._channel.wire.sendAction('get-application-manifest', {
+                    manifestUrl: requestedSnapshot
+                });
+                snapshot = response.payload.data;
+            }
+            catch (err) {
+                throw new Error(`${errMsg}: ${err}`);
+            }
+        }
+        else {
+            snapshot = requestedSnapshot;
+        }
+        if (!snapshot.windows) {
+            throw new Error(errMsg);
+        }
+        const client = await this.getClient();
+        await client.dispatch('apply-snapshot', {
+            snapshot,
+            options
+        });
+        return this;
+    }
+    /**
+     * Fetches a JSON manifest using the browser process and returns a Javascript object.
+     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.
+     * @param manifestUrl The URL of the manifest to fetch.
+     *
+     * @remarks Can be overwritten using {@link Platform#init Platform.init}.
+     *
+     * @example
+     *
+     * ```js
+     * const platform = fin.Platform.getCurrentSync();
+     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');
+     * console.log(manifest);
+     * ```
+     */
+    async fetchManifest(manifestUrl) {
+        const client = await this.getClient();
+        return client.dispatch('platform-fetch-manifest', { manifestUrl });
+    }
+    /**
+     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that
+     * resolves to the wrapped Platform.
+     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest
+     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options
+     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.
+     *
+     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the
+     * application described in startup_app options will be launched into the platform as a window with a single view.
+     * The applicable startup_app options will become View Options.
+     *
+     * @example
+     * ```js
+     * try {
+     *     const platform = fin.Platform.getCurrentSync();
+     *     await platform.launchContentManifest('http://localhost:5555/app.json');
+     *     console.log(`content launched successfully into platform`);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * // For a local manifest file:
+     * try {
+     *     const platform = fin.Platform.getCurrentSync();
+     *     platform.launchContentManifest('file:///C:/somefolder/app.json');
+     *     console.log(`content launched successfully into platform`);
+     * } catch(e) {
+     *     console.error(e);
+     * }
+     * ```
+     * @experimental
+     */
+    async launchContentManifest(manifestUrl) {
+        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {
+            // don't expose
+        });
+        const client = await this.getClient();
+        const manifest = await this.fetchManifest(manifestUrl);
+        client.dispatch('launch-into-platform', { manifest, manifestUrl });
+        return this;
+    }
+    /**
+     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.
+     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.
+     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.
+     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied
+     * to the current window (if called from a Window) or the current host window (if called from a View).
+     *
+     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a
+     * 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.
      *
-     * // we take a snapshot of the current state of the app, before changing it
-     * const snapshotOfInitialAppState = await platform.getSnapshot();
+     * @example
      *
-     * // now let's change the state of the app:
-     * await addViewToWindow(win.identity);
-     * // ... the window now has three views in it
+     * ```js
+     * // Close the current Window inside a Window context
+     * const platform = await fin.Platform.getCurrent();
+     * platform.closeWindow(fin.me.identity);
      *
-     * await platform.applySnapshot(snapshotOfInitialAppState, { closeExistingWindows: true });
-     * // ... the window will revert to previous state, with just two views
+     * // 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 applySnapshot(requestedSnapshot, options) {
-        this.wire.sendAction('platform-apply-snapshot', this.identity).catch((e) => {
+    async closeWindow(windowId, options = { skipBeforeUnload: false }) {
+        this.wire.sendAction('platform-close-window', this.identity).catch((e) => {
             // don't expose
         });
-        const errMsg = 'Requested snapshot must be a valid Snapshot object, or a url or filepath to such an object.';
-        let snapshot;
-        if (typeof requestedSnapshot === 'string') {
-            // Fetch and parse snapshot
-            try {
-                const response = await this._channel.wire.sendAction('get-application-manifest', {
-                    manifestUrl: requestedSnapshot
-                });
-                snapshot = response.payload.data;
-            }
-            catch (err) {
-                throw new Error(`${errMsg}: ${err}`);
-            }
-        }
-        else {
-            snapshot = requestedSnapshot;
-        }
-        if (!snapshot.windows) {
-            throw new Error(errMsg);
-        }
         const client = await this.getClient();
-        await client.dispatch('apply-snapshot', {
-            snapshot,
-            options
+        return client.dispatch('close-window', { windowId, options });
+    }
+}
+Instance$2.Platform = Platform;
+_Platform_connectToProvider = new WeakMap();
+
+var layout = {};
+
+var Factory$2 = {};
+
+var Instance$1 = {};
+
+var commonUtils = {};
+
+Object.defineProperty(commonUtils, "__esModule", { value: true });
+commonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;
+function isValidPresetType(type) {
+    switch (type) {
+        case 'columns':
+        case 'grid':
+        case 'rows':
+        case 'tabs':
+            return true;
+        default:
+            return false;
+    }
+}
+commonUtils.isValidPresetType = isValidPresetType;
+function overrideFromComposables(...overrides) {
+    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);
+}
+commonUtils.overrideFromComposables = overrideFromComposables;
+commonUtils.default = { isValidPresetType };
+
+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
         });
-        return this;
     }
-    /**
-     * Fetches a JSON manifest using the browser process and returns a Javascript object.
-     * Can be overwritten using {@link Platform.PlatformModule.init Platform.init}.
-     * @param manifestUrl The URL of the manifest to fetch.
-     *
-     * @remarks Can be overwritten using {@link Platform#init Platform.init}.
-     *
-     * @example
-     *
-     * ```js
-     * const platform = fin.Platform.getCurrentSync();
-     * const manifest = await platform.fetchManifest('https://www.path-to-manifest.com/app.json');
-     * console.log(manifest);
-     * ```
-     */
-    async fetchManifest(manifestUrl) {
-        const client = await this.getClient();
-        return client.dispatch('platform-fetch-manifest', { manifestUrl });
+    catch (e) {
+        if (isDisconnectedError(e.message) && relayErrorMsg) {
+            throw new Error(relayErrorMsg);
+        }
+        throw e;
     }
+};
+channelApiRelay.createRelayedDispatch = createRelayedDispatch;
+
+var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet$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 _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 {
     /**
-     * Retrieves a manifest by url and launches a legacy application manifest or snapshot into the platform.  Returns a promise that
-     * resolves to the wrapped Platform.
-     * @param manifestUrl - The URL of the manifest that will be launched into the platform.  If this app manifest
-     * contains a snapshot, that will be launched into the platform.  If not, the application described in startup_app options
-     * will be launched into the platform. The applicable startup_app options will become {@link OpenFin.ViewCreationOptions View Options}.
-     *
-     * @remarks If the app manifest contains a snapshot, that will be launched into the platform.  If not, the
-     * application described in startup_app options will be launched into the platform as a window with a single view.
-     * The applicable startup_app options will become View Options.
-     *
-     * @example
-     * ```js
-     * try {
-     *     const platform = fin.Platform.getCurrentSync();
-     *     await platform.launchContentManifest('http://localhost:5555/app.json');
-     *     console.log(`content launched successfully into platform`);
-     * } catch(e) {
-     *     console.error(e);
-     * }
-     * // For a local manifest file:
-     * try {
-     *     const platform = fin.Platform.getCurrentSync();
-     *     platform.launchContentManifest('file:///C:/somefolder/app.json');
-     *     console.log(`content launched successfully into platform`);
-     * } catch(e) {
-     *     console.error(e);
-     * }
-     * ```
-     * @experimental
+     * @internal
+     * @ignore
      */
-    async launchContentManifest(manifestUrl) {
-        this.wire.sendAction('platform-launch-content-manifest', this.identity).catch(() => {
-            // don't expose
-        });
-        const client = await this.getClient();
-        const manifest = await this.fetchManifest(manifestUrl);
-        client.dispatch('launch-into-platform', { manifest, manifestUrl });
-        return this;
+    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$5(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$5(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$5(this, _LayoutNode_client, "f").getParent(this.entityId);
+            if (!parent) {
+                return undefined;
+            }
+            return LayoutNode.getEntity(parent, __classPrivateFieldGet$5(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$5(this, _LayoutNode_client, "f").createAdjacentStack(this.entityId, views, options);
+            return LayoutNode.getEntity({ entityId, type: 'stack' }, __classPrivateFieldGet$5(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$5(this, _LayoutNode_client, "f").getAdjacentStacks({
+                targetId: this.entityId,
+                edge
+            });
+            return adjacentStacks.map((stack) => LayoutNode.getEntity({
+                type: 'stack',
+                entityId: stack.entityId
+            }, __classPrivateFieldGet$5(this, _LayoutNode_client, "f")));
+        };
+        __classPrivateFieldSet$4(this, _LayoutNode_client, client, "f");
+        this.entityId = entityId;
     }
-    /**
-     * Set the context of a host window. The context will be available to the window itself, and to its child Views. It will be saved in any platform snapshots.
-     * It can be retrieved using {@link Platform#getWindowContext getWindowContext}.
-     * @param context - A field where serializable context data can be stored to be saved in platform snapshots.
-     * @param target - A target window or view may optionally be provided. If no target is provided, the update will be applied
-     * to the current window (if called from a Window) or the current host window (if called from a View).
-     *
-     * @remarks The context data must be serializable.  This can only be called from a window or view that has been launched into a
-     * 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 }
-        });
+}
+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)})`);
     }
-    /**
-     * 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
-        });
+};
+/**
+ * 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$5(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$5(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$5(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$5(this, _TabStack_client, "f").setStackActiveView(this.entityId, view);
+        };
+        __classPrivateFieldSet$4(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 {
     /**
-     * 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
+     * @internal
      */
-    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 });
+    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$5(this, _ColumnOrRow_client, "f").getContent(this.entityId);
+            return contentItemEntities.map((entity) => LayoutNode.getEntity(entity, __classPrivateFieldGet$5(this, _ColumnOrRow_client, "f")));
+        };
+        __classPrivateFieldSet$4(this, _ColumnOrRow_client, client, "f");
+        this.type = type;
     }
 }
-Instance$2.Platform = Platform;
-_Platform_connectToProvider = new WeakMap();
-
-var layout = {};
-
-var Factory$2 = {};
-
-var Instance$1 = {};
+layoutEntities.ColumnOrRow = ColumnOrRow;
+_ColumnOrRow_client = new WeakMap();
 
-var commonUtils = {};
+var layout_constants = {};
 
-Object.defineProperty(commonUtils, "__esModule", { value: true });
-commonUtils.overrideFromComposables = commonUtils.isValidPresetType = void 0;
-function isValidPresetType(type) {
-    switch (type) {
-        case 'columns':
-        case 'grid':
-        case 'rows':
-        case 'tabs':
-            return true;
-        default:
-            return false;
-    }
-}
-commonUtils.isValidPresetType = isValidPresetType;
-function overrideFromComposables(...overrides) {
-    return (base) => overrides.reduceRight((p, c) => (b) => c(p(b)), (x) => x)(base);
-}
-commonUtils.overrideFromComposables = overrideFromComposables;
-commonUtils.default = { isValidPresetType };
+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 __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);
 };
-var _Layout_layoutClient;
+var _Layout_instances, _Layout_layoutClient, _Layout_forwardLayoutAction;
 Object.defineProperty(Instance$1, "__esModule", { value: true });
 Instance$1.Layout = void 0;
 const lazy_1 = lazy;
@@ -11880,12 +11877,19 @@ const layout_constants_1$1 = layout_constants;
  * ```
  */
 class Layout extends base_1$5.Base {
+    /**
+     * @internal
+     */
+    static getClient(layout) {
+        return __classPrivateFieldGet$4(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
@@ -12104,9 +12108,71 @@ class Layout extends base_1$5.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$4(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$4(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$4(this, _Layout_instances, "m", _Layout_forwardLayoutAction).call(this, 'layout-close-view', { viewIdentity });
+    }
 }
 Instance$1.Layout = Layout;
-_Layout_layoutClient = new WeakMap();
+_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 });
+};
 
 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");
@@ -12297,7 +12363,7 @@ class LayoutModule extends base_1$4.Base {
         this.wire.sendAction('layout-get-current').catch((e) => {
             // don't expose
         });
-        if (!this.fin.me.isWindow) {
+        if (this.wire.environment.type === 'openfin' && !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;
@@ -12320,12 +12386,50 @@ class LayoutModule extends base_1$4.Base {
         this.wire.sendAction('layout-get-current-sync').catch((e) => {
             // don't expose
         });
-        if (!this.fin.me.isWindow) {
+        if (this.wire.environment.type === 'openfin' && !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;
+            }
+            // fallback logic for missing endpoint in older runtimes
+            return this.wrapSync(layoutWindowIdentity);
+        }
+    }
 }
 Factory$2.LayoutModule = LayoutModule;
 _LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap(), _LayoutModule_getLayoutManagerSpy = new WeakMap(), _LayoutModule_instances = new WeakSet(), _LayoutModule_getSafeLayoutManager = function _LayoutModule_getSafeLayoutManager(method) {
@@ -13312,13 +13416,16 @@ 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 = requireSessionContextGroupBroker();
+	const SessionContextGroupBroker_1 = __importDefault(requireSessionContextGroupBroker());
 	const utils_1 = utils$3;
-	const lodash_1 = require$$3;
+	const isEqual_1 = __importDefault(require$$3);
 	const PrivateChannelProvider_1 = requirePrivateChannelProvider();
 	const lazy_1 = lazy;
 	const defaultContextGroups = [
@@ -13516,7 +13623,7 @@ function requireInteropBroker () {
 	            constructor(...unused) {
 	                if (unused.length) {
 	                    const [_ignore1, ignore2, opts] = unused;
-	                    if (opts && typeof opts === 'object' && !(0, lodash_1.isEqual)(opts, args[2])) {
+	                    if (opts && typeof opts === 'object' && !(0, isEqual_1.default)(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);
@@ -14693,9 +14800,32 @@ 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 = utils$3;
+const utils$1 = __importStar(utils$3);
 class PrivateChannelClient {
     constructor(client, id) {
         this.id = id;
@@ -14784,11 +14914,14 @@ 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 lodash_1 = require$$3;
+	const isEqual_1 = __importDefault(require$$3);
 	const getUnsupportedChannelApis = (channelType) => {
 	    return {
 	        addContextListener: () => {
@@ -14916,7 +15049,7 @@ PrivateChannelClient$1.PrivateChannelClient = PrivateChannelClient;
 	                const wrappedHandler = (context, contextMetadata) => {
 	                    if (first) {
 	                        first = false;
-	                        if ((0, lodash_1.isEqual)(currentContext, context)) {
+	                        if ((0, isEqual_1.default)(currentContext, context)) {
 	                            return;
 	                        }
 	                    }
@@ -15038,13 +15171,16 @@ 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 lodash_1 = require$$3;
+	const isEqual_1 = __importDefault(require$$3);
 	class FDC3ModuleBase {
 	    get client() {
 	        return __classPrivateFieldGet(this, _FDC3ModuleBase_producer, "f").call(this);
@@ -15233,7 +15369,7 @@ function requireFdc3Common () {
 	                    const wrappedHandler = (context, contextMetadata) => {
 	                        if (first) {
 	                            first = false;
-	                            if ((0, lodash_1.isEqual)(currentContext, context)) {
+	                            if ((0, isEqual_1.default)(currentContext, context)) {
 	                                return;
 	                            }
 	                        }
@@ -15846,11 +15982,14 @@ 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 = SessionContextGroupClient$1;
+	const SessionContextGroupClient_1 = __importDefault(SessionContextGroupClient$1);
 	const fdc3_1_2_1 = requireFdc31_2();
 	const fdc3_2_0_1 = requireFdc32_0();
 	const utils_1 = utils$3;
@@ -16490,9 +16629,12 @@ var hasRequiredFactory;
 function requireFactory () {
 	if (hasRequiredFactory) return Factory$1;
 	hasRequiredFactory = 1;
+	var __importDefault = (commonjsGlobal && commonjsGlobal.__importDefault) || function (mod) {
+	    return (mod && mod.__esModule) ? mod : { "default": mod };
+	};
 	Object.defineProperty(Factory$1, "__esModule", { value: true });
 	Factory$1.InteropModule = void 0;
-	const lodash_1 = require$$3;
+	const cloneDeep_1 = __importDefault(require$$0$1);
 	const inaccessibleObject_1 = inaccessibleObject;
 	const base_1 = base;
 	const InteropBroker_1 = requireInteropBroker();
@@ -16529,7 +16671,7 @@ function requireFactory () {
 	        // 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, lodash_1.cloneDeep)(options));
+	        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, cloneDeep_1.default)(options));
 	        const getProvider = () => {
 	            return this.fin.InterApplicationBus.Channel.create(`interop-broker-${name}`);
 	        };
@@ -17086,13 +17228,16 @@ var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFie
     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 _Transport_wire, _Transport_fin;
 Object.defineProperty(transport, "__esModule", { value: true });
 var Transport_1 = transport.Transport = void 0;
 const events_1$1 = require$$0;
 const wire_1 = wire;
 const transport_errors_1 = transportErrors;
-const eventAggregator_1 = eventAggregator;
+const eventAggregator_1 = __importDefault(eventAggregator);
 const me_1$1 = me;
 const errors_1 = errors;
 class Transport extends events_1$1.EventEmitter {
@@ -17319,6 +17464,9 @@ class MockEnvironment {
     async getInteropInfo() {
         throw new Error(me_1.environmentUnsupportedMessage);
     }
+    async getViewWindowIdentity() {
+        throw new Error(me_1.environmentUnsupportedMessage);
+    }
     getDefaultChannelOptions() {
         throw new Error(me_1.environmentUnsupportedMessage);
     }