@openfin/node-adapter 34.78.8 → 34.78.10

package/out/node-adapter.js

@@ -2,17 +2,16 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var require$$0 = require('events');
 var require$$3 = require('lodash');
-var require$$0$2 = require('fs');
+var require$$0$1 = require('fs');
 var require$$1$1 = require('crypto');
 var require$$2$1 = require('ws');
 var require$$1 = require('net');
-var require$$0$3 = require('path');
-var require$$0$4 = require('os');
+var require$$0$2 = require('path');
+var require$$0$3 = require('os');
 var require$$4 = require('timers');
 var require$$2 = require('child_process');
-var require$$0$1 = require('node:url');
+var require$$0 = require('node:url');
 
 function _mergeNamespaces(n, m) {
 	m.forEach(function (e) {
@@ -31,17 +30,493 @@ function _mergeNamespaces(n, m) {
 
 var commonjsGlobal = typeof globalThis !== 'undefined' ? globalThis : typeof window !== 'undefined' ? window : typeof global !== 'undefined' ? global : typeof self !== 'undefined' ? self : {};
 
-function getDefaultExportFromCjs (x) {
-	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
-}
-
 var main$1 = {};
 
 var fin = {};
 
-var system$1 = {};
+var eventsExports = {};
+var events = {
+  get exports(){ return eventsExports; },
+  set exports(v){ eventsExports = v; },
+};
+
+var R = typeof Reflect === 'object' ? Reflect : null;
+var ReflectApply = R && typeof R.apply === 'function'
+  ? R.apply
+  : function ReflectApply(target, receiver, args) {
+    return Function.prototype.apply.call(target, receiver, args);
+  };
+
+var ReflectOwnKeys;
+if (R && typeof R.ownKeys === 'function') {
+  ReflectOwnKeys = R.ownKeys;
+} else if (Object.getOwnPropertySymbols) {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target)
+      .concat(Object.getOwnPropertySymbols(target));
+  };
+} else {
+  ReflectOwnKeys = function ReflectOwnKeys(target) {
+    return Object.getOwnPropertyNames(target);
+  };
+}
+
+function ProcessEmitWarning(warning) {
+  if (console && console.warn) console.warn(warning);
+}
+
+var NumberIsNaN = Number.isNaN || function NumberIsNaN(value) {
+  return value !== value;
+};
+
+function EventEmitter() {
+  EventEmitter.init.call(this);
+}
+events.exports = EventEmitter;
+eventsExports.once = once;
+
+// Backwards-compat with node 0.10.x
+EventEmitter.EventEmitter = EventEmitter;
+
+EventEmitter.prototype._events = undefined;
+EventEmitter.prototype._eventsCount = 0;
+EventEmitter.prototype._maxListeners = undefined;
+
+// By default EventEmitters will print a warning if more than 10 listeners are
+// added to it. This is a useful default which helps finding memory leaks.
+var defaultMaxListeners = 10;
+
+function checkListener(listener) {
+  if (typeof listener !== 'function') {
+    throw new TypeError('The "listener" argument must be of type Function. Received type ' + typeof listener);
+  }
+}
+
+Object.defineProperty(EventEmitter, 'defaultMaxListeners', {
+  enumerable: true,
+  get: function() {
+    return defaultMaxListeners;
+  },
+  set: function(arg) {
+    if (typeof arg !== 'number' || arg < 0 || NumberIsNaN(arg)) {
+      throw new RangeError('The value of "defaultMaxListeners" is out of range. It must be a non-negative number. Received ' + arg + '.');
+    }
+    defaultMaxListeners = arg;
+  }
+});
+
+EventEmitter.init = function() {
+
+  if (this._events === undefined ||
+      this._events === Object.getPrototypeOf(this)._events) {
+    this._events = Object.create(null);
+    this._eventsCount = 0;
+  }
+
+  this._maxListeners = this._maxListeners || undefined;
+};
+
+// Obviously not all Emitters should be limited to 10. This function allows
+// that to be increased. Set to zero for unlimited.
+EventEmitter.prototype.setMaxListeners = function setMaxListeners(n) {
+  if (typeof n !== 'number' || n < 0 || NumberIsNaN(n)) {
+    throw new RangeError('The value of "n" is out of range. It must be a non-negative number. Received ' + n + '.');
+  }
+  this._maxListeners = n;
+  return this;
+};
+
+function _getMaxListeners(that) {
+  if (that._maxListeners === undefined)
+    return EventEmitter.defaultMaxListeners;
+  return that._maxListeners;
+}
+
+EventEmitter.prototype.getMaxListeners = function getMaxListeners() {
+  return _getMaxListeners(this);
+};
+
+EventEmitter.prototype.emit = function emit(type) {
+  var args = [];
+  for (var i = 1; i < arguments.length; i++) args.push(arguments[i]);
+  var doError = (type === 'error');
+
+  var events = this._events;
+  if (events !== undefined)
+    doError = (doError && events.error === undefined);
+  else if (!doError)
+    return false;
+
+  // If there is no 'error' event listener then throw.
+  if (doError) {
+    var er;
+    if (args.length > 0)
+      er = args[0];
+    if (er instanceof Error) {
+      // Note: The comments on the `throw` lines are intentional, they show
+      // up in Node's output if this results in an unhandled exception.
+      throw er; // Unhandled 'error' event
+    }
+    // At least give some kind of context to the user
+    var err = new Error('Unhandled error.' + (er ? ' (' + er.message + ')' : ''));
+    err.context = er;
+    throw err; // Unhandled 'error' event
+  }
+
+  var handler = events[type];
+
+  if (handler === undefined)
+    return false;
+
+  if (typeof handler === 'function') {
+    ReflectApply(handler, this, args);
+  } else {
+    var len = handler.length;
+    var listeners = arrayClone(handler, len);
+    for (var i = 0; i < len; ++i)
+      ReflectApply(listeners[i], this, args);
+  }
+
+  return true;
+};
+
+function _addListener(target, type, listener, prepend) {
+  var m;
+  var events;
+  var existing;
+
+  checkListener(listener);
+
+  events = target._events;
+  if (events === undefined) {
+    events = target._events = Object.create(null);
+    target._eventsCount = 0;
+  } else {
+    // To avoid recursion in the case that type === "newListener"! Before
+    // adding it to the listeners, first emit "newListener".
+    if (events.newListener !== undefined) {
+      target.emit('newListener', type,
+                  listener.listener ? listener.listener : listener);
+
+      // Re-assign `events` because a newListener handler could have caused the
+      // this._events to be assigned to a new object
+      events = target._events;
+    }
+    existing = events[type];
+  }
+
+  if (existing === undefined) {
+    // Optimize the case of one listener. Don't need the extra array object.
+    existing = events[type] = listener;
+    ++target._eventsCount;
+  } else {
+    if (typeof existing === 'function') {
+      // Adding the second element, need to change to array.
+      existing = events[type] =
+        prepend ? [listener, existing] : [existing, listener];
+      // If we've already got an array, just append.
+    } else if (prepend) {
+      existing.unshift(listener);
+    } else {
+      existing.push(listener);
+    }
+
+    // Check for listener leak
+    m = _getMaxListeners(target);
+    if (m > 0 && existing.length > m && !existing.warned) {
+      existing.warned = true;
+      // No error code for this since it is a Warning
+      // eslint-disable-next-line no-restricted-syntax
+      var w = new Error('Possible EventEmitter memory leak detected. ' +
+                          existing.length + ' ' + String(type) + ' listeners ' +
+                          'added. Use emitter.setMaxListeners() to ' +
+                          'increase limit');
+      w.name = 'MaxListenersExceededWarning';
+      w.emitter = target;
+      w.type = type;
+      w.count = existing.length;
+      ProcessEmitWarning(w);
+    }
+  }
+
+  return target;
+}
+
+EventEmitter.prototype.addListener = function addListener(type, listener) {
+  return _addListener(this, type, listener, false);
+};
+
+EventEmitter.prototype.on = EventEmitter.prototype.addListener;
+
+EventEmitter.prototype.prependListener =
+    function prependListener(type, listener) {
+      return _addListener(this, type, listener, true);
+    };
+
+function onceWrapper() {
+  if (!this.fired) {
+    this.target.removeListener(this.type, this.wrapFn);
+    this.fired = true;
+    if (arguments.length === 0)
+      return this.listener.call(this.target);
+    return this.listener.apply(this.target, arguments);
+  }
+}
+
+function _onceWrap(target, type, listener) {
+  var state = { fired: false, wrapFn: undefined, target: target, type: type, listener: listener };
+  var wrapped = onceWrapper.bind(state);
+  wrapped.listener = listener;
+  state.wrapFn = wrapped;
+  return wrapped;
+}
+
+EventEmitter.prototype.once = function once(type, listener) {
+  checkListener(listener);
+  this.on(type, _onceWrap(this, type, listener));
+  return this;
+};
+
+EventEmitter.prototype.prependOnceListener =
+    function prependOnceListener(type, listener) {
+      checkListener(listener);
+      this.prependListener(type, _onceWrap(this, type, listener));
+      return this;
+    };
+
+// Emits a 'removeListener' event if and only if the listener was removed.
+EventEmitter.prototype.removeListener =
+    function removeListener(type, listener) {
+      var list, events, position, i, originalListener;
+
+      checkListener(listener);
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      list = events[type];
+      if (list === undefined)
+        return this;
+
+      if (list === listener || list.listener === listener) {
+        if (--this._eventsCount === 0)
+          this._events = Object.create(null);
+        else {
+          delete events[type];
+          if (events.removeListener)
+            this.emit('removeListener', type, list.listener || listener);
+        }
+      } else if (typeof list !== 'function') {
+        position = -1;
+
+        for (i = list.length - 1; i >= 0; i--) {
+          if (list[i] === listener || list[i].listener === listener) {
+            originalListener = list[i].listener;
+            position = i;
+            break;
+          }
+        }
+
+        if (position < 0)
+          return this;
+
+        if (position === 0)
+          list.shift();
+        else {
+          spliceOne(list, position);
+        }
+
+        if (list.length === 1)
+          events[type] = list[0];
+
+        if (events.removeListener !== undefined)
+          this.emit('removeListener', type, originalListener || listener);
+      }
+
+      return this;
+    };
+
+EventEmitter.prototype.off = EventEmitter.prototype.removeListener;
+
+EventEmitter.prototype.removeAllListeners =
+    function removeAllListeners(type) {
+      var listeners, events, i;
+
+      events = this._events;
+      if (events === undefined)
+        return this;
+
+      // not listening for removeListener, no need to emit
+      if (events.removeListener === undefined) {
+        if (arguments.length === 0) {
+          this._events = Object.create(null);
+          this._eventsCount = 0;
+        } else if (events[type] !== undefined) {
+          if (--this._eventsCount === 0)
+            this._events = Object.create(null);
+          else
+            delete events[type];
+        }
+        return this;
+      }
+
+      // emit removeListener for all listeners on all events
+      if (arguments.length === 0) {
+        var keys = Object.keys(events);
+        var key;
+        for (i = 0; i < keys.length; ++i) {
+          key = keys[i];
+          if (key === 'removeListener') continue;
+          this.removeAllListeners(key);
+        }
+        this.removeAllListeners('removeListener');
+        this._events = Object.create(null);
+        this._eventsCount = 0;
+        return this;
+      }
+
+      listeners = events[type];
+
+      if (typeof listeners === 'function') {
+        this.removeListener(type, listeners);
+      } else if (listeners !== undefined) {
+        // LIFO order
+        for (i = listeners.length - 1; i >= 0; i--) {
+          this.removeListener(type, listeners[i]);
+        }
+      }
+
+      return this;
+    };
+
+function _listeners(target, type, unwrap) {
+  var events = target._events;
+
+  if (events === undefined)
+    return [];
+
+  var evlistener = events[type];
+  if (evlistener === undefined)
+    return [];
+
+  if (typeof evlistener === 'function')
+    return unwrap ? [evlistener.listener || evlistener] : [evlistener];
+
+  return unwrap ?
+    unwrapListeners(evlistener) : arrayClone(evlistener, evlistener.length);
+}
+
+EventEmitter.prototype.listeners = function listeners(type) {
+  return _listeners(this, type, true);
+};
+
+EventEmitter.prototype.rawListeners = function rawListeners(type) {
+  return _listeners(this, type, false);
+};
+
+EventEmitter.listenerCount = function(emitter, type) {
+  if (typeof emitter.listenerCount === 'function') {
+    return emitter.listenerCount(type);
+  } else {
+    return listenerCount.call(emitter, type);
+  }
+};
+
+EventEmitter.prototype.listenerCount = listenerCount;
+function listenerCount(type) {
+  var events = this._events;
+
+  if (events !== undefined) {
+    var evlistener = events[type];
+
+    if (typeof evlistener === 'function') {
+      return 1;
+    } else if (evlistener !== undefined) {
+      return evlistener.length;
+    }
+  }
+
+  return 0;
+}
+
+EventEmitter.prototype.eventNames = function eventNames() {
+  return this._eventsCount > 0 ? ReflectOwnKeys(this._events) : [];
+};
+
+function arrayClone(arr, n) {
+  var copy = new Array(n);
+  for (var i = 0; i < n; ++i)
+    copy[i] = arr[i];
+  return copy;
+}
+
+function spliceOne(list, index) {
+  for (; index + 1 < list.length; index++)
+    list[index] = list[index + 1];
+  list.pop();
+}
+
+function unwrapListeners(arr) {
+  var ret = new Array(arr.length);
+  for (var i = 0; i < ret.length; ++i) {
+    ret[i] = arr[i].listener || arr[i];
+  }
+  return ret;
+}
+
+function once(emitter, name) {
+  return new Promise(function (resolve, reject) {
+    function errorListener(err) {
+      emitter.removeListener(name, resolver);
+      reject(err);
+    }
+
+    function resolver() {
+      if (typeof emitter.removeListener === 'function') {
+        emitter.removeListener('error', errorListener);
+      }
+      resolve([].slice.call(arguments));
+    }
+    eventTargetAgnosticAddListener(emitter, name, resolver, { once: true });
+    if (name !== 'error') {
+      addErrorHandlerIfEventEmitter(emitter, errorListener, { once: true });
+    }
+  });
+}
+
+function addErrorHandlerIfEventEmitter(emitter, handler, flags) {
+  if (typeof emitter.on === 'function') {
+    eventTargetAgnosticAddListener(emitter, 'error', handler, flags);
+  }
+}
+
+function eventTargetAgnosticAddListener(emitter, name, listener, flags) {
+  if (typeof emitter.on === 'function') {
+    if (flags.once) {
+      emitter.once(name, listener);
+    } else {
+      emitter.on(name, listener);
+    }
+  } else if (typeof emitter.addEventListener === 'function') {
+    // EventTarget does not have `error` event semantics like Node
+    // EventEmitters, we do not listen for `error` events here.
+    emitter.addEventListener(name, function wrapListener(arg) {
+      // IE does not have builtin `{ once: true }` support so we
+      // have to do it manually.
+      if (flags.once) {
+        emitter.removeEventListener(name, wrapListener);
+      }
+      listener(arg);
+    });
+  } else {
+    throw new TypeError('The "emitter" argument must be of type EventEmitter. Received type ' + typeof emitter);
+  }
+}
+
+var system = {};
 
-var base$1 = {};
+var base = {};
 
 var promises = {};
 
@@ -84,8 +559,8 @@ var __classPrivateFieldGet$f = (commonjsGlobal && commonjsGlobal.__classPrivateF
     return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
 };
 var _EmitterBase_emitterAccessor;
-Object.defineProperty(base$1, "__esModule", { value: true });
-base$1.Reply = base$1.EmitterBase = base$1.Base = void 0;
+Object.defineProperty(base, "__esModule", { value: true });
+base.Reply = base.EmitterBase = base.Base = void 0;
 const promises_1$2 = promises;
 class Base {
     /**
@@ -106,18 +581,11 @@ class Base {
     get fin() {
         return this.wire.getFin();
     }
-    /**
-     * Provides access to the OpenFin representation of the current code context (usually a document
-     * such as a {@link OpenFin.View} or {@link OpenFin.Window}), as well as to the current `Interop` context.
-     *
-     * Useful for debugging in the devtools console, where this will intelligently type itself based
-     * on the context in which the devtools panel was opened.
-     */
     get me() {
         return this.wire.me;
     }
 }
-base$1.Base = Base;
+base.Base = Base;
 /**
  * An entity that emits OpenFin events.
  *
@@ -147,9 +615,6 @@ class EmitterBase extends Base {
         this.topic = topic;
         _EmitterBase_emitterAccessor.set(this, void 0);
         this.eventNames = () => (this.hasEmitter() ? this.getOrCreateEmitter().eventNames() : []);
-        /**
-         * @internal
-         */
         this.emit = (eventType, payload, ...args) => {
             return this.hasEmitter() ? this.getOrCreateEmitter().emit(eventType, payload, ...args) : false;
         };
@@ -192,13 +657,16 @@ class EmitterBase extends Base {
             // This will only be reached if unsubscribe from event that does not exist but do not want to error here
             return Promise.resolve();
         };
+        this.addListener = this.on;
         __classPrivateFieldSet$d(this, _EmitterBase_emitterAccessor, [topic, ...additionalAccessors], "f");
         this.listeners = (event) => this.hasEmitter() ? this.getOrCreateEmitter().listeners(event) : [];
     }
     /**
      * Adds a listener to the end of the listeners array for the specified event.
      *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     * @param eventType
+     * @param listener
+     * @param options
      */
     async on(eventType, listener, options) {
         await this.registerEventListener(eventType, options, (emitter) => {
@@ -208,16 +676,12 @@ class EmitterBase extends Base {
         });
         return this;
     }
-    /**
-     * Adds a listener to the end of the listeners array for the specified event.
-     */
-    async addListener(eventType, listener, options) {
-        return this.on(eventType, listener, options);
-    }
     /**
      * Adds a one time listener for the event. The listener is invoked only the first time the event is fired, after which it is removed.
      *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     * @param eventType
+     * @param listener
+     * @param options
      */
     async once(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
@@ -233,7 +697,9 @@ class EmitterBase extends Base {
     /**
      * Adds a listener to the beginning of the listeners array for the specified event.
      *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     * @param eventType
+     * @param listener
+     * @param options
      */
     async prependListener(eventType, listener, options) {
         await this.registerEventListener(eventType, options, (emitter) => {
@@ -247,7 +713,9 @@ class EmitterBase extends Base {
      * Adds a one time listener for the event. The listener is invoked only the first time the event is fired,
      * after which it is removed. The listener is added to the beginning of the listeners array.
      *
-     * @remarks Event payloads are documented in the {@link OpenFin.Events} namespace.
+     * @param eventType
+     * @param listener
+     * @param options
      */
     async prependOnceListener(eventType, listener, options) {
         const deregister = () => this.deregisterEventListener(eventType);
@@ -264,6 +732,10 @@ class EmitterBase extends Base {
      * Remove a listener from the listener array for the specified event.
      *
      * @remarks Caution: Calling this method changes the array indices in the listener array behind the listener.
+     *
+     * @param eventType
+     * @param listener
+     * @param options
      */
     async removeListener(eventType, listener, options) {
         const emitter = await this.deregisterEventListener(eventType, options);
@@ -290,6 +762,7 @@ class EmitterBase extends Base {
     /**
      * Removes all listeners, or those of the specified event.
      *
+     * @param eventType
      */
     async removeAllListeners(eventType) {
         const removeByEvent = async (event) => {
@@ -314,11 +787,11 @@ class EmitterBase extends Base {
         }
     }
 }
-base$1.EmitterBase = EmitterBase;
+base.EmitterBase = EmitterBase;
 _EmitterBase_emitterAccessor = new WeakMap();
 class Reply {
 }
-base$1.Reply = Reply;
+base.Reply = Reply;
 
 var transportErrors = {};
 
@@ -351,7 +824,7 @@ class InternalError extends Error {
         const { message, name, stack, ...rest } = err;
         super(message);
         this.name = name || 'Error';
-        this.stack = stack ?? this.toString();
+        this.stack = stack !== null && stack !== void 0 ? stack : this.toString();
         Object.keys(rest).forEach(key => {
             this[key] = rest[key];
         });
@@ -360,6 +833,7 @@ class InternalError extends Error {
 // For documentation of the error methods being used see here: https://v8.dev/docs/stack-trace-api
 class RuntimeError extends Error {
     static getCallSite(callsToRemove = 0) {
+        var _a, _b;
         const length = Error.stackTraceLimit;
         const realCallsToRemove = callsToRemove + 1; // remove this call;
         Error.stackTraceLimit = length + realCallsToRemove;
@@ -368,7 +842,7 @@ class RuntimeError extends Error {
         // This will be called when we access the `stack` property
         Error.prepareStackTrace = (_, stack) => stack;
         // stack is optional in non chromium contexts
-        const stack = new Error().stack?.slice(realCallsToRemove) ?? [];
+        const stack = (_b = (_a = new Error().stack) === null || _a === void 0 ? void 0 : _a.slice(realCallsToRemove)) !== null && _b !== void 0 ? _b : [];
         Error.prepareStackTrace = _prepareStackTrace;
         Error.stackTraceLimit = length;
         return stack;
@@ -390,7 +864,7 @@ class RuntimeError extends Error {
         const { reason, error } = payload;
         super(reason);
         this.name = 'RuntimeError';
-        if (error?.stack) {
+        if (error === null || error === void 0 ? void 0 : error.stack) {
             this.cause = new InternalError(error);
         }
         if (callSites) {
@@ -400,7 +874,7 @@ class RuntimeError extends Error {
 }
 transportErrors.RuntimeError = RuntimeError;
 
-var window$2 = {};
+var window$1 = {};
 
 var Factory$8 = {};
 
@@ -419,30 +893,16 @@ validate.validateIdentity = validateIdentity;
 
 var Instance$7 = {};
 
-var application$1 = {};
+var application = {};
 
 var Factory$7 = {};
 
 var Instance$6 = {};
 
-var view$1 = {};
+var view = {};
 
 var Factory$6 = {};
 
-var warnings = {};
-
-Object.defineProperty(warnings, "__esModule", { value: true });
-warnings.handleDeprecatedWarnings = void 0;
-const handleDeprecatedWarnings = (options) => {
-    if (options.contentNavigation?.whitelist ||
-        options.contentNavigation?.blacklist ||
-        options.contentRedirect?.whitelist ||
-        options.contentRedirect?.blacklist) {
-        console.warn(`The properties 'whitelist' and 'blacklist' have been marked as deprecated and will be removed in a future version. Please use 'allowlist' and 'denylist'.`);
-    }
-};
-warnings.handleDeprecatedWarnings = handleDeprecatedWarnings;
-
 var hasRequiredFactory$3;
 
 function requireFactory$3 () {
@@ -450,10 +910,9 @@ function requireFactory$3 () {
 	hasRequiredFactory$3 = 1;
 	Object.defineProperty(Factory$6, "__esModule", { value: true });
 	Factory$6.ViewModule = void 0;
-	const base_1 = base$1;
+	const base_1 = base;
 	const validate_1 = validate;
 	const index_1 = requireView();
-	const warnings_1 = warnings;
 	/**
 	 * Static namespace for OpenFin API methods that interact with the {@link View} class, available under `fin.View`.
 	 */
@@ -491,7 +950,6 @@ function requireFactory$3 () {
 	        if (!options.name || typeof options.name !== 'string') {
 	            throw new Error('Please provide a name property as a string in order to create a View.');
 	        }
-	        (0, warnings_1.handleDeprecatedWarnings)(options);
 	        if (this.wire.environment.childViews) {
 	            await this.wire.environment.createChildContent({
 	                entityType: 'view',
@@ -779,7 +1237,7 @@ class ChannelsExposer {
         this.exposeFunction = async (target, config) => {
             const { key, options, meta } = config;
             const { id } = meta;
-            const action = `${id}.${options?.action || key}`;
+            const action = `${id}.${(options === null || options === void 0 ? void 0 : options.action) || key}`;
             await this.channelProviderOrClient.register(action, async ({ args }) => {
                 return target(...args);
             });
@@ -810,7 +1268,7 @@ channelsExposer.ChannelsExposer = ChannelsExposer;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	__exportStar(channelsConsumer, exports);
-	__exportStar(channelsExposer, exports); 
+	__exportStar(channelsExposer, exports);
 } (openfinChannels));
 
 (function (exports) {
@@ -829,7 +1287,7 @@ channelsExposer.ChannelsExposer = ChannelsExposer;
 	    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); 
+	__exportStar(openfinChannels, exports);
 } (strategies));
 
 (function (exports) {
@@ -851,7 +1309,7 @@ channelsExposer.ChannelsExposer = ChannelsExposer;
 	__exportStar(apiConsumer, exports);
 	__exportStar(apiExposer, exports);
 	__exportStar(strategies, exports);
-	__exportStar(decorators, exports); 
+	__exportStar(decorators, exports);
 } (apiExposer$1));
 
 var channelApiRelay = {};
@@ -1092,14 +1550,14 @@ _LayoutNode_client = new WeakMap();
 /**
  * @ignore
  * @internal
- * Encapsulates Api consumption of {@link LayoutEntitiesClient} with a relayed dispatch
+ * Encapsulates Api consumption of {@link LayoutEntitiesController} 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 dispatch = (0, channel_api_relay_1.createRelayedDispatch)(client, identity, 'layout-relay', 'You are trying to interact with a layout component on a window that has been destroyed.');
     const consumer = new api_exposer_1.ApiConsumer(new api_exposer_1.ChannelsConsumer({ dispatch }));
     return consumer.consume({ id: controllerId });
 };
@@ -1409,20 +1867,15 @@ _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 = void 0;
 layout_constants.LAYOUT_CONTROLLER_ID = 'layout-entities';
-layout_constants.DEFAULT_LAYOUT_KEY = 'default';
 
 var main = {};
 
 Object.defineProperty(main, "__esModule", { value: true });
 main.WebContents = void 0;
-const base_1$k = base$1;
+const base_1$k = base;
 class WebContents extends base_1$k.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;
@@ -1475,11 +1928,6 @@ class WebContents extends base_1$k.EmitterBase {
      * }
      * 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);
@@ -1515,10 +1963,6 @@ class WebContents extends base_1$k.EmitterBase {
      *
      * 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
@@ -1558,10 +2002,6 @@ class WebContents extends base_1$k.EmitterBase {
      *
      * 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);
@@ -1600,10 +2040,6 @@ class WebContents extends base_1$k.EmitterBase {
      *
      * 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);
@@ -1611,7 +2047,7 @@ class WebContents extends base_1$k.EmitterBase {
     /**
      * Navigates the WebContents to a specified URL.
      *
-     * Note: The url must contain the protocol prefix such as http:// or https://.
+     * @remarks The url must contain the protocol prefix such as http:// or https://.
      * @param url - The URL to navigate the WebContents to.
      *
      * @example
@@ -1641,10 +2077,6 @@ class WebContents extends base_1$k.EmitterBase {
      * 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);
@@ -1672,10 +2104,6 @@ class WebContents extends base_1$k.EmitterBase {
      * }
      * navigateBack().then(() => console.log('Navigated back')).catch(err => console.log(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     navigateBack() {
         return this.wire.sendAction('navigate-window-back', { ...this.identity }).then(() => undefined);
@@ -1705,10 +2133,6 @@ class WebContents extends base_1$k.EmitterBase {
      * }
      * navigateForward().then(() => console.log('Navigated forward')).catch(err => console.log(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async navigateForward() {
         await this.wire.sendAction('navigate-window-forward', { ...this.identity });
@@ -1736,10 +2160,6 @@ class WebContents extends base_1$k.EmitterBase {
      * }
      * stopNavigation().then(() => console.log('you shall not navigate')).catch(err => console.log(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     stopNavigation() {
         return this.wire.sendAction('stop-window-navigation', { ...this.identity }).then(() => undefined);
@@ -1777,10 +2197,6 @@ class WebContents extends base_1$k.EmitterBase {
      * 		console.log('Reloaded window')
      * }).catch(err => console.log(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     reload(ignoreCache = false) {
         return this.wire
@@ -1794,7 +2210,7 @@ class WebContents extends base_1$k.EmitterBase {
      * Prints the WebContents.
      * @param options Printer Options
      *
-     * Note: When `silent` is set to `true`, the API will pick the system's default printer if deviceName
+     * @remarks When `silent` is set to `true`, the API will pick the system's default printer if deviceName
      * is empty and the default settings for printing.
      *
      * Use the CSS style `page-break-before: always;` to force print to a new page.
@@ -1807,10 +2223,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     console.log('print call has been sent to the system');
      * });
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     print(options = {}) {
         return this.wire.sendAction('print', { ...this.identity, options }).then(() => undefined);
@@ -1820,7 +2232,7 @@ class WebContents extends base_1$k.EmitterBase {
      * @param searchTerm Term to find in page
      * @param options Search options
      *
-     * Note: By default, each subsequent call will highlight the next text that matches the search term.
+     * @remarks By default, each subsequent call will highlight the next text that matches the search term.
      *
      * Returns a promise with the results for the request. By subscribing to the
      * found-in-page event, you can get the results of this call as well.
@@ -1855,10 +2267,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     console.log(result)
      * });
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     findInPage(searchTerm, options) {
         return this.wire
@@ -1902,10 +2310,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     console.log(results);
      * });
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     stopFindInPage(action) {
         return this.wire.sendAction('stop-find-in-page', { ...this.identity, action }).then(() => undefined);
@@ -1948,10 +2352,6 @@ class WebContents extends base_1$k.EmitterBase {
      *         console.log(err);
      *     });
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     getPrinters() {
         return this.wire.sendAction('get-printers', { ...this.identity }).then(({ payload }) => payload.data);
@@ -1974,10 +2374,6 @@ class WebContents extends base_1$k.EmitterBase {
      *
      * focusWindow().then(() => console.log('Window focused')).catch(err => console.log(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async focus({ emitSynthFocused } = { emitSynthFocused: true }) {
         await this.wire.sendAction('focus-window', { emitSynthFocused, ...this.identity });
@@ -2009,10 +2405,6 @@ class WebContents extends base_1$k.EmitterBase {
      * .then(() => console.log('Showing dev tools'))
      * .catch(err => console.error(err));
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async showDeveloperTools() {
         // Note this hits the system action map in core state for legacy reasons.
@@ -2021,7 +2413,7 @@ class WebContents extends base_1$k.EmitterBase {
     /**
      * Retrieves the process information associated with a WebContents.
      *
-     * Note: This includes any iframes associated with the WebContents
+     * @remarks This includes any iframes associated with the WebContents
      *
      * @example
      * View:
@@ -2035,10 +2427,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     const win = await fin.Window.getCurrent();
      *     const processInfo = await win.getProcessInfo();
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async getProcessInfo() {
         const { payload: { data } } = await this.wire.sendAction('get-process-info', this.identity);
@@ -2074,10 +2462,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     const win = await fin.Window.create(winOption);
      *     const sharedWorkers = await win.getSharedWorkers();
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async getSharedWorkers() {
         return this.wire.sendAction('get-shared-workers', this.identity).then(({ payload }) => payload.data);
@@ -2112,10 +2496,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     const win = await fin.Window.create(winOption);
      *     await win.inspectSharedWorker();
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async inspectSharedWorker() {
         await this.wire.sendAction('inspect-shared-worker', { ...this.identity });
@@ -2153,10 +2533,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     const sharedWorkers = await win.getSharedWorkers();
      *     await win.inspectSharedWorkerById(sharedWorkers[0].id);
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async inspectSharedWorkerById(workerId) {
         await this.wire.sendAction('inspect-shared-worker-by-id', { ...this.identity, workerId });
@@ -2191,10 +2567,6 @@ class WebContents extends base_1$k.EmitterBase {
      *     const win = await fin.Window.create(winOption);
      *     await win.inspectServiceWorker();
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async inspectServiceWorker() {
         await this.wire.sendAction('inspect-service-worker', { ...this.identity });
@@ -2202,7 +2574,7 @@ class WebContents extends base_1$k.EmitterBase {
     /**
      * Shows a popup window.
      *
-     * Note: If this WebContents is a view and its attached window has a popup open, this will close it.
+     * @remarks If this WebContents is a view and its attached window has a popup open, this will close it.
      *
      * Shows a popup window. Including a `name` in `options` will attempt to show an existing window as a popup, if
      * that window doesn't exist or no `name` is included a window will be created. If the caller view or the caller
@@ -2210,7 +2582,7 @@ class WebContents extends base_1$k.EmitterBase {
      * open popup window before showing the new popup window. Also, if the caller view is destroyed or detached, the popup
      * will be dismissed.
      *
-     * Note: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.
+     * NOTE: in the case where the window being shown as a popup needs to be created, it is a child of the caller view's parent window.
      *
      * @example
      *
@@ -2405,16 +2777,12 @@ class WebContents extends base_1$k.EmitterBase {
      *     onPopupReady: popupWindowCallback;
      * });
      * ```
-     * @remarks
-     * `WebContents` refers to shared functionality between {@link OpenFin.Window} and {@link OpenFin.View}.
-     * We do not expose an explicit superclass for this functionality, but it does have its own
-     * {@link OpenFin.WebContentsEvents event namespace}.
      */
     async showPopupWindow(options) {
         this.wire.sendAction(`${this.entityType}-show-popup-window`, this.identity).catch(() => {
             // we do not want to expose this error, just continue if this analytics-only call fails
         });
-        if (options?.onPopupReady) {
+        if (options === null || options === void 0 ? void 0 : options.onPopupReady) {
             const readyListener = async ({ popupName }) => {
                 try {
                     const popupWindow = this.fin.Window.wrapSync({ uuid: this.fin.me.uuid, name: popupName });
@@ -2433,8 +2801,8 @@ class WebContents extends base_1$k.EmitterBase {
                 ...options,
                 // Internal use only.
                 // @ts-expect-error
-                hasResultCallback: !!options?.onPopupResult,
-                hasReadyCallback: !!options?.onPopupReady
+                hasResultCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupResult),
+                hasReadyCallback: !!(options === null || options === void 0 ? void 0 : options.onPopupReady)
             },
             ...this.identity
         });
@@ -2459,7 +2827,7 @@ class WebContents extends base_1$k.EmitterBase {
             }
             return popupResult;
         };
-        if (options?.onPopupResult) {
+        if (options === null || options === void 0 ? void 0 : options.onPopupResult) {
             const dispatchResultListener = async (payload) => {
                 await options.onPopupResult(normalizePopupResult(payload));
             };
@@ -2785,49 +3153,6 @@ function requireInstance$2 () {
 	        this.show = async () => {
 	            await this.wire.sendAction('show-view', { ...this.identity });
 	        };
-	        /**
-	         * Sets the bounds (top, left, width, height) of the view relative to its window and shows it if it is hidden.
-	         * This method ensures the view is both positioned and showing. It will reposition a visible view and both show and reposition a hidden view.
-	         *
-	         * @remarks View position is relative to the bounds of the window.
-	         * ({top: 0, left: 0} represents the top left corner of the window)
-	         *
-	         * @example
-	         * ```js
-	         * let view;
-	         * async function createView() {
-	         *     const me = await fin.Window.getCurrent();
-	         *     return fin.View.create({
-	         *         name: 'viewNameSetBounds',
-	         *         target: me.identity,
-	         *         bounds: {top: 10, left: 10, width: 200, height: 200}
-	         *     });
-	         * }
-	         *
-	         * async function showViewAt() {
-	         *     view = await createView();
-	         *     console.log('View created.');
-	         *
-	         *     await view.navigate('https://google.com');
-	         *     console.log('View navigated to given url.');
-	         *
-	         *     await view.showAt({
-	         *         top: 100,
-	         *         left: 100,
-	         *         width: 300,
-	         *         height: 300
-	         *     });
-	         * }
-	         *
-	         * showViewAt()
-	         *     .then(() => console.log('View set to new bounds and shown.'))
-	         *     .catch(err => console.log(err));
-	         * ```
-	         * @experimental
-	         */
-	        this.showAt = async (bounds) => {
-	            await this.wire.sendAction('show-view-at', { bounds, ...this.identity });
-	        };
 	        /**
 	         * Hides the current view if it is currently visible.
 	         *
@@ -2987,24 +3312,8 @@ function requireInstance$2 () {
 	            this.wire.sendAction('view-get-parent-layout', { ...this.identity }).catch(() => {
 	                // don't expose
 	            });
-	            const layoutWindow = await this.getCurrentWindow();
-	            try {
-	                const providerChannelClient = await __classPrivateFieldGet(this, _View_providerChannelClient, "f").getValue();
-	                const client = await layout_entities_1.LayoutNode.newLayoutEntitiesClient(providerChannelClient, layout_constants_1.LAYOUT_CONTROLLER_ID, layoutWindow.identity);
-	                const layoutIdentity = await client.getLayoutIdentityForViewOrThrow(this.identity);
-	                return this.fin.Platform.Layout.wrap(layoutIdentity);
-	            }
-	            catch (e) {
-	                const allowedErrors = [
-	                    'No action registered at target for',
-	                    'getLayoutIdentityForViewOrThrow is not a function'
-	                ];
-	                if (!allowedErrors.some((m) => e.message.includes(m))) {
-	                    throw e;
-	                }
-	                // fallback logic for missing endpoint
-	                return this.fin.Platform.Layout.wrap(layoutWindow.identity);
-	            }
+	            const currentWindow = await this.getCurrentWindow();
+	            return currentWindow.getLayout();
 	        };
 	        /**
 	         * Gets the View's options.
@@ -3219,7 +3528,7 @@ function requireInstance$2 () {
 var hasRequiredView;
 
 function requireView () {
-	if (hasRequiredView) return view$1;
+	if (hasRequiredView) return view;
 	hasRequiredView = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -3238,9 +3547,9 @@ function requireView () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		/**
-		 * Entry points for the OpenFin `View` API (`fin.View`).
+		 * Entry points for the OpenFin `View` API.
 		 *
-		 * * {@link ViewModule} contains static members of the `View` API, accessible through `fin.View`.
+		 * * {@link ViewModule} contains static methods relating to the `View` type, accessible through `fin.View`.
 		 * * {@link View} describes an instance of an OpenFin View, e.g. as returned by `fin.View.getCurrent`.
 		 *
 		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -3249,9 +3558,9 @@ function requireView () {
 		 * @packageDocumentation
 		 */
 		__exportStar(requireFactory$3(), exports);
-		__exportStar(requireInstance$2(), exports); 
-	} (view$1));
-	return view$1;
+		__exportStar(requireInstance$2(), exports);
+} (view));
+	return view;
 }
 
 var hasRequiredInstance$1;
@@ -3262,7 +3571,7 @@ function requireInstance$1 () {
 	Object.defineProperty(Instance$6, "__esModule", { value: true });
 	Instance$6.Application = void 0;
 	/* eslint-disable import/prefer-default-export */
-	const base_1 = base$1;
+	const base_1 = base;
 	const window_1 = requireWindow();
 	const view_1 = requireView();
 	/**
@@ -3737,7 +4046,6 @@ function requireInstance$1 () {
 	    /**
 	     * Sets or removes a custom JumpList for the application. Only applicable in Windows OS.
 	     * If categories is null the previously set custom JumpList (if any) will be replaced by the standard JumpList for the app (managed by Windows).
-	     *
 	     * Note: If the "name" property is omitted it defaults to "tasks".
 	     * @param jumpListCategories An array of JumpList Categories to populate. If null, remove any existing JumpList configuration and set to Windows default.
 	     *
@@ -4038,7 +4346,6 @@ function requireInstance$1 () {
 	    }
 	    /**
 	     * Sets file auto download location. It's only allowed in the same application.
-	     *
 	     * Note: This method is restricted by default and must be enabled via
 	     * <a href="https://developers.openfin.co/docs/api-security">API security settings</a>.
 	     * @param downloadLocation file auto download location
@@ -4064,7 +4371,6 @@ function requireInstance$1 () {
 	    }
 	    /**
 	     * Gets file auto download location. It's only allowed in the same application. If file auto download location is not set, it will return the default location.
-	     *
 	     * Note: This method is restricted by default and must be enabled via
 	     * <a href="https://developers.openfin.co/docs/api-security">API security settings</a>.
 	     *
@@ -4092,7 +4398,7 @@ function requireFactory$2 () {
 	hasRequiredFactory$2 = 1;
 	Object.defineProperty(Factory$7, "__esModule", { value: true });
 	Factory$7.ApplicationModule = void 0;
-	const base_1 = base$1;
+	const base_1 = base;
 	const validate_1 = validate;
 	const Instance_1 = requireInstance$1();
 	/**
@@ -4360,7 +4666,7 @@ function requireFactory$2 () {
 var hasRequiredApplication;
 
 function requireApplication () {
-	if (hasRequiredApplication) return application$1;
+	if (hasRequiredApplication) return application;
 	hasRequiredApplication = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -4379,9 +4685,9 @@ function requireApplication () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		/**
-		 * Entry points for the OpenFin `Application` API (`fin.Application`).
+		 * Entry points for the OpenFin `Application` API.
 		 *
-		 * * {@link ApplicationModule} contains static members of the `Application` API, accessible through `fin.Application`.
+		 * * {@link ApplicationModule} contains static methods relating to the `Application` type, accessible through `fin.Application`.
 		 * * {@link Application} describes an instance of an OpenFin Application, e.g. as returned by `fin.Application.getCurrent`.
 		 *
 		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -4390,9 +4696,9 @@ function requireApplication () {
 		 * @packageDocumentation
 		 */
 		__exportStar(requireFactory$2(), exports);
-		__exportStar(requireInstance$1(), exports); 
-	} (application$1));
-	return application$1;
+		__exportStar(requireInstance$1(), exports);
+} (application));
+	return application;
 }
 
 var hasRequiredInstance;
@@ -4409,7 +4715,6 @@ function requireInstance () {
 	const application_1 = requireApplication();
 	const main_1 = main;
 	const view_1 = requireView();
-	const warnings_1 = warnings;
 	/**
 	 * @PORTED
 	 * @typedef { object } Margins
@@ -4894,6 +5199,7 @@ function requireInstance () {
 	     */
 	    constructor(wire, identity) {
 	        super(wire, identity, 'window');
+	        this.identity = identity;
 	    }
 	    /**
 	     * Adds a listener to the end of the listeners array for the specified event.
@@ -5019,7 +5325,6 @@ function requireInstance () {
 	            if (options.autoShow === undefined) {
 	                options.autoShow = true;
 	            }
-	            (0, warnings_1.handleDeprecatedWarnings)(options);
 	            const windowCreation = this.wire.environment.createChildContent({ entityType: 'window', options });
 	            Promise.all([pageResponse, windowCreation])
 	                .then((resolvedArr) => {
@@ -5436,15 +5741,15 @@ function requireInstance () {
 	     * ```
 	     * @experimental
 	     */
-	    async getLayout(layoutIdentity) {
+	    async getLayout() {
 	        this.wire.sendAction('window-get-layout', this.identity).catch((e) => {
 	            // don't expose
 	        });
 	        const opts = await this.getOptions();
-	        if (!opts.layout || !opts.layoutSnapshot) {
+	        if (!opts.layout) {
 	            throw new Error('Window does not have a Layout');
 	        }
-	        return this.fin.Platform.Layout.wrap(layoutIdentity ?? this.identity);
+	        return this.fin.Platform.Layout.wrap(this.identity);
 	    }
 	    /**
 	     * Gets the current settings of the window.
@@ -6073,10 +6378,7 @@ function requireInstance () {
 	     * Calling this method will close previously opened menus.
 	     * @experimental
 	     * @param options
-	     * @typeParam Data User-defined shape for data returned upon menu item click.  Should be a
-	     * [union](https://www.typescriptlang.org/docs/handbook/2/everyday-types.html#union-types)
-	     * of all possible data shapes for the entire menu, and the click handler should process
-	     * these with a "reducer" pattern.
+	     *
 	     * @example
 	     * This could be used to show a drop down menu over views in a platform window:
 	     * ```js
@@ -6275,7 +6577,7 @@ function requireFactory$1 () {
 	hasRequiredFactory$1 = 1;
 	Object.defineProperty(Factory$8, "__esModule", { value: true });
 	Factory$8._WindowModule = void 0;
-	const base_1 = base$1;
+	const base_1 = base;
 	const validate_1 = validate;
 	const Instance_1 = requireInstance();
 	/**
@@ -6417,7 +6719,7 @@ function requireFactory$1 () {
 var hasRequiredWindow;
 
 function requireWindow () {
-	if (hasRequiredWindow) return window$2;
+	if (hasRequiredWindow) return window$1;
 	hasRequiredWindow = 1;
 	(function (exports) {
 		var __createBinding = (commonjsGlobal && commonjsGlobal.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -6436,9 +6738,9 @@ function requireWindow () {
 		};
 		Object.defineProperty(exports, "__esModule", { value: true });
 		/**
-		 * Entry points for the OpenFin `Window` API (`fin.Window`).
+		 * Entry points for the OpenFin `Window` API.
 		 *
-		 * * {@link _WindowModule} contains static members of the `Window` API, accessible through `fin.Window`.
+		 * * {@link _WindowModule} contains static methods relating to the `Window` type, accessible through `fin.Window`.
 		 * * {@link _Window} describes an instance of an OpenFin Window, e.g. as returned by `fin.Window.getCurrent`.
 		 *
 		 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -6449,24 +6751,17 @@ function requireWindow () {
 		 * @packageDocumentation
 		 */
 		__exportStar(requireFactory$1(), exports);
-		__exportStar(requireInstance(), exports); 
-	} (window$2));
-	return window$2;
+		__exportStar(requireInstance(), exports);
+} (window$1));
+	return window$1;
 }
 
-/**
- * Entry point for the OpenFin `System` API (`fin.System`).
- *
- * * {@link System} contains static members of the `System` API (available under `fin.System`)
- *
- * @packageDocumentation
- */
-Object.defineProperty(system$1, "__esModule", { value: true });
-system$1.System = void 0;
-const base_1$j = base$1;
+Object.defineProperty(system, "__esModule", { value: true });
+system.System = void 0;
+const base_1$j = base;
 const transport_errors_1$2 = transportErrors;
 const window_1 = requireWindow();
-const events_1$6 = require$$0;
+const events_1$6 = eventsExports;
 /**
  * An object representing the core of OpenFin Runtime. Allows the developer
  * to perform system-level actions, such as accessing logs, viewing processes,
@@ -7436,59 +7731,6 @@ class System extends base_1$j.EmitterBase {
     openUrlWithBrowser(url) {
         return this.wire.sendAction('open-url-with-browser', { url }).then(() => undefined);
     }
-    /**
-     * Creates a new registry entry under the HKCU root Windows registry key if the given custom protocol name doesn't exist or
-     * overwrites the existing registry entry if the given custom protocol name already exists.
-     *
-     * Note: This method is restricted by default and must be enabled via
-     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.
-     *
-     *
-     * @remarks These protocols are reserved and cannot be registered:
-     * - fin
-     * - fins
-     * - openfin
-     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}
-     *
-     * @throws if a given custom protocol failed to be registered.
-     * @throws if a manifest URL contains the '%1' string.
-     * @throws if a manifest URL contains a query string parameter which name equals to the Protocol Launch Request Parameter Name.
-     * @throws if the full length of the command string that is to be written to the registry exceeds 2048 bytes.
-     *
-     * @example
-     * ```js
-     * fin.System.registerCustomProtocol({protocolName:'protocol1'}).then(console.log).catch(console.error);
-     * ```
-     */
-    async registerCustomProtocol(options) {
-        if (typeof options !== 'object') {
-            throw new Error('Must provide an object with a `protocolName` property having a string value.');
-        }
-        await this.wire.sendAction('register-custom-protocol', options);
-    }
-    /**
-     * Removes the registry entry for a given custom protocol.
-     *
-     * Note: This method is restricted by default and must be enabled via
-     * {@link https://developers.openfin.co/docs/api-security API security settings}. It requires RVM 12 or higher version.
-     *
-     *
-     * @remarks These protocols are reserved and cannot be unregistered:
-     * - fin
-     * - fins
-     * - openfin
-     * - URI Schemes registered with {@link https://en.wikipedia.org/wiki/List_of_URI_schemes#Official_IANA-registered_schemes IANA}
-     *
-     * @throws if a protocol entry failed to be removed in registry.
-     *
-     * @example
-     * ```js
-     * await fin.System.unregisterCustomProtocol('protocol1');
-     * ```
-     */
-    async unregisterCustomProtocol(protocolName) {
-        await this.wire.sendAction('unregister-custom-protocol', { protocolName });
-    }
     /**
      * Removes the process entry for the passed UUID obtained from a prior call
      * of fin.System.launchExternalProcess().
@@ -7521,8 +7763,7 @@ class System extends base_1$j.EmitterBase {
     }
     /**
      * Attempt to close an external process. The process will be terminated if it
-     * has not closed after the elapsed timeout in milliseconds.
-     *
+     * has not closed after the elapsed timeout in milliseconds.<br>
      * Note: This method is restricted by default and must be enabled via
      * <a href="https://developers.openfin.co/docs/api-security">API security settings</a>.
      * @param options A object defined in the TerminateExternalRequestType interface
@@ -7558,8 +7799,7 @@ class System extends base_1$j.EmitterBase {
         return this.wire.sendAction('update-proxy', options).then(() => undefined);
     }
     /**
-     * Downloads the given application asset.
-     *
+     * Downloads the given application asset<br>
      * Note: This method is restricted by default and must be enabled via
      * <a href="https://developers.openfin.co/docs/api-security">API security settings</a>.
      * @param appAsset App asset object
@@ -8362,7 +8602,7 @@ class System extends base_1$j.EmitterBase {
         await this.wire.sendAction('set-domain-settings', { domainSettings, ...this.identity });
     }
 }
-system$1.System = System;
+system.System = System;
 
 var interappbus = {};
 
@@ -8453,7 +8693,7 @@ class ChannelBase {
         try {
             const mainAction = this.subscriptions.has(topic)
                 ? this.subscriptions.get(topic)
-                : (currentPayload, id) => (this.defaultAction ?? ChannelBase.defaultAction)(topic, currentPayload, id);
+                : (currentPayload, id) => { var _a; return ((_a = this.defaultAction) !== null && _a !== void 0 ? _a : ChannelBase.defaultAction)(topic, currentPayload, id); };
             const preActionProcessed = this.preAction ? await this.preAction(topic, payload, senderIdentity) : payload;
             const actionProcessed = await mainAction(preActionProcessed, senderIdentity);
             return this.postAction ? await this.postAction(topic, actionProcessed, senderIdentity) : actionProcessed;
@@ -8986,6 +9226,7 @@ class ClassicStrategy {
         // connection problems occur
         _ClassicStrategy_pendingMessagesByEndpointId.set(this, new Map);
         this.send = async (endpointId, action, payload) => {
+            var _a;
             const to = __classPrivateFieldGet$c(this, _ClassicStrategy_endpointIdentityMap, "f").get(endpointId);
             if (!to) {
                 throw new Error(`Could not locate routing info for endpoint ${endpointId}`);
@@ -9005,12 +9246,13 @@ class ClassicStrategy {
                 action,
                 payload
             });
-            __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.add(p);
+            (_a = __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.add(p);
             const raw = await p.catch((error) => {
                 throw new Error(error.message);
             }).finally(() => {
+                var _a;
                 // clean up the pending promise
-                __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)?.delete(p);
+                (_a = __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").get(endpointId)) === null || _a === void 0 ? void 0 : _a.delete(p);
             });
             return raw.payload.data.result;
         };
@@ -9031,8 +9273,8 @@ class ClassicStrategy {
         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.`;
+        pendingSet === null || pendingSet === void 0 ? void 0 : pendingSet.forEach((p) => {
+            const errorMsg = `Channel connection with identity uuid: ${id === null || id === void 0 ? void 0 : id.uuid} / name: ${id === null || id === void 0 ? void 0 : id.name} / endpointId: ${endpointId} no longer connected.`;
             p.cancel(new Error(errorMsg));
         });
     }
@@ -9044,8 +9286,9 @@ class ClassicStrategy {
         __classPrivateFieldGet$c(this, _ClassicStrategy_pendingMessagesByEndpointId, "f").set(endpointId, new Set());
     }
     isValidEndpointPayload(payload) {
-        return (typeof payload?.endpointIdentity?.endpointId === 'string' ||
-            typeof payload?.endpointIdentity?.channelId === 'string');
+        var _a, _b;
+        return (typeof ((_a = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _a === void 0 ? void 0 : _a.endpointId) === 'string' ||
+            typeof ((_b = payload === null || payload === void 0 ? void 0 : payload.endpointIdentity) === null || _b === void 0 ? void 0 : _b.channelId) === 'string');
     }
 }
 strategy$2.ClassicStrategy = ClassicStrategy;
@@ -9122,12 +9365,13 @@ class RTCEndpoint {
             this.rtc.rtcClient.close();
         };
         this.rtc.channels.response.addEventListener('message', (e) => {
+            var _a;
             let { data } = e;
             if (e.data instanceof ArrayBuffer) {
                 data = new TextDecoder().decode(e.data);
             }
             const { messageId, payload, success, error } = JSON.parse(data);
-            const { resolve, reject } = this.responseMap.get(messageId) ?? {};
+            const { resolve, reject } = (_a = this.responseMap.get(messageId)) !== null && _a !== void 0 ? _a : {};
             if (resolve && reject) {
                 this.responseMap.delete(messageId);
                 if (success) {
@@ -9300,7 +9544,7 @@ var iceManager = {};
 
 Object.defineProperty(iceManager, "__esModule", { value: true });
 iceManager.RTCICEManager = void 0;
-const base_1$i = base$1;
+const base_1$i = base;
 /*
 Singleton that facilitates Offer and Answer exchange required for establishing RTC connections.
 */
@@ -9376,8 +9620,9 @@ class RTCICEManager extends base_1$i.EmitterBase {
         const rtcConnectionId = Math.random().toString();
         const rtcClient = this.createRtcPeer();
         rtcClient.addEventListener('icecandidate', async (e) => {
+            var _a;
             if (e.candidate) {
-                await this.raiseClientIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });
+                await this.raiseClientIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
             }
         });
         await this.listenForProviderIce(rtcConnectionId, async (payload) => {
@@ -9402,8 +9647,9 @@ class RTCICEManager extends base_1$i.EmitterBase {
         const requestChannelPromise = RTCICEManager.createDataChannelPromise('request', rtcClient);
         const responseChannelPromise = RTCICEManager.createDataChannelPromise('response', rtcClient);
         rtcClient.addEventListener('icecandidate', async (e) => {
+            var _a;
             if (e.candidate) {
-                await this.raiseProviderIce(rtcConnectionId, { candidate: e.candidate?.toJSON() });
+                await this.raiseProviderIce(rtcConnectionId, { candidate: (_a = e.candidate) === null || _a === void 0 ? void 0 : _a.toJSON() });
             }
         });
         await this.listenForClientIce(rtcConnectionId, async (payload) => {
@@ -9585,7 +9831,8 @@ class ChannelProvider extends channel_1.ChannelBase {
      * ```
      */
     dispatch(to, action, payload) {
-        const endpointId = to.endpointId ?? this.getEndpointIdForOpenFinId(to, action);
+        var _a;
+        const endpointId = (_a = to.endpointId) !== null && _a !== void 0 ? _a : this.getEndpointIdForOpenFinId(to, action);
         if (endpointId && __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").isEndpointConnected(endpointId)) {
             return __classPrivateFieldGet$9(this, _ChannelProvider_strategy, "f").send(endpointId, action, payload);
         }
@@ -9761,12 +10008,13 @@ class ChannelProvider extends channel_1.ChannelBase {
         }
     }
     getEndpointIdForOpenFinId(clientIdentity, action) {
+        var _a;
         const matchingConnections = this.connections.filter((c) => c.name === clientIdentity.name && c.uuid === clientIdentity.uuid);
         if (matchingConnections.length >= 2) {
             const protectedObj = __classPrivateFieldGet$9(this, _ChannelProvider_protectedObj, "f");
             const { uuid, name } = clientIdentity;
-            const providerUuid = protectedObj?.providerIdentity.uuid;
-            const providerName = protectedObj?.providerIdentity.name;
+            const providerUuid = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.uuid;
+            const providerName = protectedObj === null || protectedObj === void 0 ? void 0 : protectedObj.providerIdentity.name;
             // eslint-disable-next-line no-console
             console.warn(`WARNING: Dispatch call may have unintended results. The "to" argument of your dispatch call is missing the
                 "endpointId" parameter. The identity you are dispatching to ({uuid: ${uuid}, name: ${name}})
@@ -9774,7 +10022,7 @@ class ChannelProvider extends channel_1.ChannelBase {
                 ({uuid: ${providerUuid}, name: ${providerName}}) will only be processed by the most recently-created client.`);
         }
         // Pop to return the most recently created endpointId.
-        return matchingConnections.pop()?.endpointId;
+        return (_a = matchingConnections.pop()) === null || _a === void 0 ? void 0 : _a.endpointId;
     }
     // eslint-disable-next-line class-methods-use-this
     static clientIdentityIncludesEndpointId(subscriptionIdentity) {
@@ -9791,12 +10039,12 @@ _ChannelProvider_connections = new WeakMap(), _ChannelProvider_protectedObj = ne
 // static #removalMap = new WeakMap<ChannelProvider, Function>();
 ChannelProvider.removalMap = new WeakMap();
 
-var messageReceiver$1 = {};
+var messageReceiver = {};
 
-Object.defineProperty(messageReceiver$1, "__esModule", { value: true });
-messageReceiver$1.MessageReceiver = void 0;
+Object.defineProperty(messageReceiver, "__esModule", { value: true });
+messageReceiver.MessageReceiver = void 0;
 const client_1$1 = client;
-const base_1$h = base$1;
+const base_1$h = base;
 /*
 This is a singleton (per fin object) tasked with routing messages coming off the ipc to the correct endpoint.
 It needs to be a singleton because there can only be one per wire. It tracks both clients and providers' processAction passed in via the strategy.
@@ -9817,10 +10065,9 @@ class MessageReceiver extends base_1$h.Base {
         wire.registerMessageHandler(this.onmessage.bind(this));
     }
     async processChannelMessage(msg) {
+        var _a, _b;
         const { senderIdentity, providerIdentity, action, ackToSender, payload, intendedTargetIdentity } = msg.payload;
-        const key = intendedTargetIdentity.channelId ?? // The recipient is a provider
-            intendedTargetIdentity.endpointId ?? // The recipient is a client
-            this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt
+        const key = (_b = (_a = intendedTargetIdentity.channelId) !== null && _a !== void 0 ? _a : intendedTargetIdentity.endpointId) !== null && _b !== void 0 ? _b : this.latestEndpointIdByChannelId.get(providerIdentity.channelId); // No endpointId was passed, make best attempt
         const handler = this.endpointMap.get(key);
         if (!handler) {
             ackToSender.payload.success = false;
@@ -9865,7 +10112,7 @@ class MessageReceiver extends base_1$h.Base {
         }
     }
 }
-messageReceiver$1.MessageReceiver = MessageReceiver;
+messageReceiver.MessageReceiver = MessageReceiver;
 
 var protocolManager = {};
 
@@ -9900,9 +10147,12 @@ class ProtocolManager {
             return supported;
         };
         this.getCompatibleProtocols = (providerProtocols, clientOffer) => {
-            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => providerProtocol.type === clientProtocol.type &&
-                clientProtocol.version >= providerProtocol.minimumVersion &&
-                providerProtocol.version >= (clientProtocol.minimumVersion ?? 0)));
+            const supported = clientOffer.supportedProtocols.filter((clientProtocol) => providerProtocols.some((providerProtocol) => {
+                var _a;
+                return providerProtocol.type === clientProtocol.type &&
+                    clientProtocol.version >= providerProtocol.minimumVersion &&
+                    providerProtocol.version >= ((_a = clientProtocol.minimumVersion) !== null && _a !== void 0 ? _a : 0);
+            }));
             return supported.slice(0, clientOffer.maxProtocols);
         };
     }
@@ -9984,12 +10234,12 @@ var _ConnectionManager_messageReceiver, _ConnectionManager_rtcConnectionManager;
 Object.defineProperty(connectionManager, "__esModule", { value: true });
 connectionManager.ConnectionManager = void 0;
 const exhaustive_1 = exhaustive;
-const base_1$g = base$1;
+const base_1$g = base;
 const strategy_1 = strategy$2;
 const strategy_2 = strategy$1;
 const ice_manager_1 = iceManager;
 const provider_1$1 = provider;
-const message_receiver_1 = messageReceiver$1;
+const message_receiver_1 = messageReceiver;
 const protocol_manager_1 = protocolManager;
 const strategy_3 = strategy;
 class ConnectionManager extends base_1$g.Base {
@@ -10027,7 +10277,7 @@ class ConnectionManager extends base_1$g.Base {
     }
     createProvider(options, providerIdentity) {
         const opts = Object.assign(this.wire.environment.getDefaultChannelOptions().create, options || {});
-        const protocols = this.protocolManager.getProviderProtocols(opts?.protocols);
+        const protocols = this.protocolManager.getProviderProtocols(opts === null || opts === void 0 ? void 0 : opts.protocols);
         const createSingleStrategy = (stratType) => {
             switch (stratType) {
                 case 'rtc':
@@ -10064,7 +10314,7 @@ class ConnectionManager extends base_1$g.Base {
         return channel;
     }
     async createClientOffer(options) {
-        const protocols = this.protocolManager.getClientProtocols(options?.protocols);
+        const protocols = this.protocolManager.getClientProtocols(options === null || options === void 0 ? void 0 : options.protocols);
         let rtcPacket;
         const supportedProtocols = await Promise.all(protocols.map(async (type) => {
             switch (type) {
@@ -10092,13 +10342,14 @@ class ConnectionManager extends base_1$g.Base {
         };
     }
     async createClientStrategy(rtcPacket, routingInfo) {
+        var _a;
         if (!routingInfo.endpointId) {
             routingInfo.endpointId = this.wire.environment.getNextMessageId();
             // For New Clients connecting to Old Providers. To prevent multi-dispatching and publishing, we delete previously-connected
             // clients that are in the same context as the newly-connected client.
             __classPrivateFieldGet$8(this, _ConnectionManager_messageReceiver, "f").checkForPreviousClientConnection(routingInfo.channelId);
         }
-        const answer = routingInfo.answer ?? {
+        const answer = (_a = routingInfo.answer) !== null && _a !== void 0 ? _a : {
             supportedProtocols: [{ type: 'classic', version: 1 }]
         };
         const createStrategyFromAnswer = async (protocol) => {
@@ -10156,7 +10407,7 @@ class ConnectionManager extends base_1$g.Base {
             if (!(provider instanceof provider_1$1.ChannelProvider)) {
                 throw Error('Cannot connect to a channel client');
             }
-            const offer = clientOffer ?? {
+            const offer = clientOffer !== null && clientOffer !== void 0 ? clientOffer : {
                 supportedProtocols: [{ type: 'classic', version: 1 }],
                 maxProtocols: 1
             };
@@ -10214,15 +10465,6 @@ class ConnectionManager extends base_1$g.Base {
 connectionManager.ConnectionManager = ConnectionManager;
 _ConnectionManager_messageReceiver = new WeakMap(), _ConnectionManager_rtcConnectionManager = new WeakMap();
 
-/**
- * Entry points for the `Channel` subset of the `InterApplicationBus` API (`fin.InterApplicationBus.Channel`).
- *
- * * {@link Channel} contains static members of the `Channel` API, accessible through `fin.InterApplicationBus.Channel`.
- * * {@link OpenFin.ChannelClient} describes a client of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.connect`.
- * * {@link OpenFin.ChannelProvider} describes a provider of a channel, e.g. as returned by `fin.InterApplicationBus.Channel.create`.
- *
- * @packageDocumentation
- */
 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");
@@ -10238,9 +10480,9 @@ var _Channel_connectionManager, _Channel_internalEmitter, _Channel_readyToConnec
 Object.defineProperty(channel$1, "__esModule", { value: true });
 channel$1.Channel = void 0;
 /* eslint-disable no-console */
-const events_1$5 = require$$0;
+const events_1$5 = eventsExports;
 const lazy_1$1 = lazy;
-const base_1$f = base$1;
+const base_1$f = base;
 const client_1 = client;
 const connection_manager_1 = connectionManager;
 const provider_1 = provider;
@@ -10558,15 +10800,8 @@ _Channel_connectionManager = new WeakMap(), _Channel_internalEmitter = new WeakM
 
 Object.defineProperty(interappbus, "__esModule", { value: true });
 interappbus.InterAppPayload = interappbus.InterApplicationBus = void 0;
-/**
- * Entry point for the OpenFin `InterApplicationBus` API (`fin.InterApplicationBus`).
- *
- * * {@link InterApplicationBus} contains static members of the `InterApplicationBus` API, accessible through `fin.InterApplicationBus`.
- *
- * @packageDocumentation
- */
-const events_1$4 = require$$0;
-const base_1$e = base$1;
+const events_1$4 = eventsExports;
+const base_1$e = base;
 const ref_counter_1 = refCounter;
 const index_1$2 = channel$1;
 const validate_1$3 = validate;
@@ -10773,16 +11008,9 @@ function createKey(...toHash) {
 
 var clipboard = {};
 
-/**
- * Entry point for the OpenFin `Clipboard` API (`fin.Clipboard`).
- *
- * * {@link Clipboard} contains static members of the `Clipboard` API, accessible through `fin.Clipboard`.
- *
- * @packageDocumentation
- */
 Object.defineProperty(clipboard, "__esModule", { value: true });
 clipboard.Clipboard = void 0;
-const base_1$d = base$1;
+const base_1$d = base;
 /**
  * @PORTED
  * WriteRequestType interface
@@ -10981,7 +11209,7 @@ class Clipboard extends base_1$d.Base {
 }
 clipboard.Clipboard = Clipboard;
 
-var externalApplication$1 = {};
+var externalApplication = {};
 
 var Factory$5 = {};
 
@@ -10990,7 +11218,7 @@ var Instance$4 = {};
 Object.defineProperty(Instance$4, "__esModule", { value: true });
 Instance$4.ExternalApplication = void 0;
 /* eslint-disable import/prefer-default-export */
-const base_1$c = base$1;
+const base_1$c = base;
 /**
  * An ExternalApplication object representing native language adapter connections to the runtime. Allows
  * the developer to listen to {@link OpenFin.ExternalApplicationEvents external application events}.
@@ -11106,7 +11334,7 @@ Instance$4.ExternalApplication = ExternalApplication;
 
 Object.defineProperty(Factory$5, "__esModule", { value: true });
 Factory$5.ExternalApplicationModule = void 0;
-const base_1$b = base$1;
+const base_1$b = base;
 const Instance_1$4 = Instance$4;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link ExternalApplication} class, available under `fin.ExternalApplication`.
@@ -11170,9 +11398,9 @@ Factory$5.ExternalApplicationModule = ExternalApplicationModule;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	/**
-	 * Entry points for the OpenFin `ExternalApplication` API (`fin.ExternalApplication`).
+	 * Entry points for the OpenFin `ExternalApplication` API.
 	 *
-	 * * {@link ExternalApplicationModule} contains static members of the `ExternalApplication` type, accessible through `fin.ExternalApplication`.
+	 * * {@link ExternalApplicationModule} contains static methods relating to the `ExternalApplication` type, accessible through `fin.ExternalApplication`.
 	 * * {@link ExternalApplication} describes an instance of an OpenFin ExternalApplication, e.g. as returned by `fin.ExternalApplication.getCurrent`.
 	 *
 	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -11181,10 +11409,10 @@ Factory$5.ExternalApplicationModule = ExternalApplicationModule;
 	 * @packageDocumentation
 	 */
 	__exportStar(Factory$5, exports);
-	__exportStar(Instance$4, exports); 
-} (externalApplication$1));
+	__exportStar(Instance$4, exports);
+} (externalApplication));
 
-var frame$1 = {};
+var frame = {};
 
 var Factory$4 = {};
 
@@ -11193,7 +11421,7 @@ var Instance$3 = {};
 Object.defineProperty(Instance$3, "__esModule", { value: true });
 Instance$3._Frame = void 0;
 /* eslint-disable import/prefer-default-export */
-const base_1$a = base$1;
+const base_1$a = base;
 /**
  * An iframe represents an embedded HTML page within a parent HTML page. Because this embedded page
  * has its own DOM and global JS context (which may or may not be linked to that of the parent depending
@@ -11335,7 +11563,7 @@ Instance$3._Frame = _Frame;
 
 Object.defineProperty(Factory$4, "__esModule", { value: true });
 Factory$4._FrameModule = void 0;
-const base_1$9 = base$1;
+const base_1$9 = base;
 const validate_1$2 = validate;
 const Instance_1$3 = Instance$3;
 /**
@@ -11421,9 +11649,9 @@ Factory$4._FrameModule = _FrameModule;
 
 (function (exports) {
 	/**
-	 * Entry points for the OpenFin `Frame` API (`fin.Frame`).
+	 * Entry points for the OpenFin `Frame` API.
 	 *
-	 * * {@link _FrameModule} contains static members of the `Frame` API, accessible through `fin.Frame`.
+	 * * {@link _FrameModule} contains static methods relating to the `Frame` type, accessible through `fin.Frame`.
 	 * * {@link _Frame} describes an instance of an OpenFin Frame, e.g. as returned by `fin.Frame.getCurrent`.
 	 *
 	 * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -11449,14 +11677,14 @@ Factory$4._FrameModule = _FrameModule;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	__exportStar(Factory$4, exports);
-	__exportStar(Instance$3, exports); 
-} (frame$1));
+	__exportStar(Instance$3, exports);
+} (frame));
 
-var globalHotkey$1 = {};
+var globalHotkey = {};
 
-Object.defineProperty(globalHotkey$1, "__esModule", { value: true });
-globalHotkey$1.GlobalHotkey = void 0;
-const base_1$8 = base$1;
+Object.defineProperty(globalHotkey, "__esModule", { value: true });
+globalHotkey.GlobalHotkey = void 0;
+const base_1$8 = base;
 /**
  * The GlobalHotkey module can register/unregister a global hotkeys.
  *
@@ -11472,8 +11700,6 @@ class GlobalHotkey extends base_1$8.EmitterBase {
      * Registers a global hotkey with the operating system.
      * @param hotkey a hotkey string
      * @param listener called when the registered hotkey is pressed by the user.
-     * @throws If the `hotkey` is reserved, see list below.
-     * @throws if the `hotkey` is already registered by another application.
      *
      * @remarks The `hotkey` parameter expects an electron compatible [accelerator](https://github.com/electron/electron/blob/master/docs/api/accelerator.md) and the `listener` will be called if the `hotkey` is pressed by the user.
      * If successfull, the hotkey will be 'claimed' by the application, meaning that this register call can be called multiple times from within the same application but will fail if another application has registered the hotkey.
@@ -11566,7 +11792,7 @@ class GlobalHotkey extends base_1$8.EmitterBase {
         return undefined;
     }
     /**
-     * Checks if a given hotkey has been registered by an application within the current runtime.
+     * Checks if a given hotkey has been registered
      * @param hotkey a hotkey string
      *
      * @example
@@ -11587,9 +11813,9 @@ class GlobalHotkey extends base_1$8.EmitterBase {
         return data;
     }
 }
-globalHotkey$1.GlobalHotkey = GlobalHotkey;
+globalHotkey.GlobalHotkey = GlobalHotkey;
 
-var platform$1 = {};
+var platform = {};
 
 var Factory$3 = {};
 
@@ -11604,14 +11830,16 @@ var _Platform_connectToProvider;
 Object.defineProperty(Instance$2, "__esModule", { value: true });
 Instance$2.Platform = void 0;
 /* eslint-disable import/prefer-default-export, no-undef */
-const base_1$7 = base$1;
+const base_1$7 = base;
 const validate_1$1 = validate;
 // Reuse clients to avoid overwriting already-registered client in provider
 const clientMap = new Map();
 /** Manages the life cycle of windows and views in the application.
  *
- * Enables taking snapshots of itself and applying them to restore a previous configuration
+ * Enables taking snapshots of itself and applyi
+ * ng them to restore a previous configuration
  * as well as listen to {@link OpenFin.PlatformEvents platform events}.
+ *
  */
 class Platform extends base_1$7.EmitterBase {
     /**
@@ -11977,6 +12205,7 @@ class Platform extends base_1$7.EmitterBase {
      *
      */
     async reparentView(viewIdentity, target) {
+        var _a;
         // eslint-disable-next-line no-console
         console.warn('Platform.reparentView has been deprecated, please use Platform.createView');
         this.wire.sendAction('platform-reparent-view', this.identity).catch((e) => {
@@ -11984,7 +12213,7 @@ class Platform extends base_1$7.EmitterBase {
         });
         const normalizedViewIdentity = {
             ...viewIdentity,
-            uuid: viewIdentity.uuid ?? this.identity.uuid
+            uuid: (_a = viewIdentity.uuid) !== null && _a !== void 0 ? _a : this.identity.uuid
         };
         const view = await this.fin.View.wrap(normalizedViewIdentity);
         const viewOptions = await view.getOptions();
@@ -12463,7 +12692,7 @@ Object.defineProperty(Instance$1, "__esModule", { value: true });
 Instance$1.Layout = void 0;
 const lazy_1 = lazy;
 const validate_1 = validate;
-const base_1$6 = base$1;
+const base_1$6 = base;
 const common_utils_1 = commonUtils;
 const layout_entities_1 = layoutEntities;
 const layout_constants_1 = layout_constants;
@@ -12772,30 +13001,10 @@ class Layout extends base_1$6.Base {
             // don't expose
         });
         const client = await this.platform.getClient();
-        console.log(`Layout::toConfig() called!`);
         return client.dispatch('get-frame-snapshot', {
             target: this.identity
         });
     }
-    /**
-     * Retrieves the attached views in current window layout.
-     *
-     * @example
-     * ```js
-     * const layout = fin.Platform.Layout.getCurrentSync();
-     * const views = await layout.getCurrentViews();
-     * ```
-     */
-    async getCurrentViews() {
-        this.wire.sendAction('layout-get-views').catch((e) => {
-            // don't expose
-        });
-        const client = await this.platform.getClient();
-        const viewIdentities = await client.dispatch('get-layout-views', {
-            target: this.identity
-        });
-        return viewIdentities.map((identity) => this.fin.View.wrapSync(identity));
-    }
     /**
      * Retrieves the top level content item of the layout.
      *
@@ -12822,7 +13031,7 @@ class Layout extends base_1$6.Base {
             // don't expose
         });
         const client = await __classPrivateFieldGet$5(this, _Layout_layoutClient, "f").getValue();
-        const root = await client.getRoot(this.identity);
+        const root = await client.getRoot();
         return layout_entities_1.LayoutNode.getEntity(root, client);
     }
 }
@@ -12840,11 +13049,11 @@ var __classPrivateFieldSet$4 = (commonjsGlobal && commonjsGlobal.__classPrivateF
     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 _LayoutModule_layoutInitializationAttempted, _LayoutModule_layoutManager;
+var _LayoutModule_layoutInitializationAttempted;
 Object.defineProperty(Factory$2, "__esModule", { value: true });
 Factory$2.LayoutModule = void 0;
 /* eslint-disable no-undef, import/prefer-default-export */
-const base_1$5 = base$1;
+const base_1$5 = base;
 const Instance_1$2 = Instance$1;
 /**
  * Static namespace for OpenFin API methods that interact with the {@link Layout} class, available under `fin.Platform.Layout`.
@@ -12853,7 +13062,6 @@ class LayoutModule extends base_1$5.Base {
     constructor() {
         super(...arguments);
         _LayoutModule_layoutInitializationAttempted.set(this, false);
-        _LayoutModule_layoutManager.set(this, null);
         /**
          * Initialize the window's Layout.
          *
@@ -12903,17 +13111,7 @@ class LayoutModule extends base_1$5.Base {
                 throw new Error('Layout for this window already initialized, please use Layout.replace call to replace the layout.');
             }
             __classPrivateFieldSet$4(this, _LayoutModule_layoutInitializationAttempted, true, "f");
-            // TODO: remove this.wire and always use this.fin
-            __classPrivateFieldSet$4(this, _LayoutModule_layoutManager, await this.wire.environment.initLayout(this.fin, this.wire, options), "f");
-            // TODO: if create() wasn't called, warn!! aka, if lm.getLayouts().length === 0
-            const layoutInstance = await __classPrivateFieldGet$4(this, _LayoutModule_layoutManager, "f").resolveLayout();
-            const layout = this.wrapSync(layoutInstance.identity);
-            // Adding this to the returned instance undocumented/typed for Browser
-            // TODO: if not overridden, then return layoutManager: layoutInstance
-            return Object.assign(layout, { layoutManager: layoutInstance });
-        };
-        this.getCurrentLayoutManagerSync = () => {
-            return __classPrivateFieldGet$4(this, _LayoutModule_layoutManager, "f");
+            return this.wire.environment.initLayout(this.fin, this.wire, options);
         };
     }
     /**
@@ -13011,13 +13209,13 @@ class LayoutModule extends base_1$5.Base {
     }
 }
 Factory$2.LayoutModule = LayoutModule;
-_LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layoutManager = new WeakMap();
+_LayoutModule_layoutInitializationAttempted = new WeakMap();
 
 (function (exports) {
 	/**
-	 * Entry point for the OpenFin `Layout` subset of the `Platform` API (`fin.Platform.Layout`).
+	 * Entry point for the OpenFin `Layout` namespace.
 	 *
-	 * * {@link LayoutModule} contains static members of the `Layout` API, accessible through `fin.Platform.Layout`.
+	 * * {@link LayoutModule} contains static methods relating to the `Layout` type, accessible through `fin.Platform.Layout`.
 	 * * {@link Layout} describes an instance of an OpenFin Layout, e.g. as returned by `fin.Platform.Layout.getCurrent`.
 	 *
 	 * These are separate code entities, and are documented separately. In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -13042,12 +13240,12 @@ _LayoutModule_layoutInitializationAttempted = new WeakMap(), _LayoutModule_layou
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	__exportStar(Factory$2, exports);
-	__exportStar(Instance$1, exports); 
+	__exportStar(Instance$1, exports);
 } (layout));
 
 Object.defineProperty(Factory$3, "__esModule", { value: true });
 Factory$3.PlatformModule = void 0;
-const base_1$4 = base$1;
+const base_1$4 = base;
 const Instance_1$1 = Instance$2;
 const index_1$1 = layout;
 /**
@@ -13296,9 +13494,9 @@ Factory$3.PlatformModule = PlatformModule;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	/**
-	 * Entry points for the OpenFin `Platform` API (`fin.Platform`)
+	 * Entry points for the OpenFin `Platform` API.
 	 *
-	 * * {@link PlatformModule} contains static members of the `Platform` API, accessible through `fin.Platform`.
+	 * * {@link PlatformModule} contains static methods relating to the `Platform` type, accessible through `fin.Platform`.
 	 * * {@link Platform} describes an instance of an OpenFin Platform, e.g. as returned by `fin.Platform.getCurrent`.
 	 *
 	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -13307,8 +13505,8 @@ Factory$3.PlatformModule = PlatformModule;
 	 * @packageDocumentation
 	 */
 	__exportStar(Factory$3, exports);
-	__exportStar(Instance$2, exports); 
-} (platform$1));
+	__exportStar(Instance$2, exports);
+} (platform));
 
 var me = {};
 
@@ -13316,9 +13514,9 @@ var me = {};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.getMe = exports.getBaseMe = exports.environmentUnsupportedMessage = void 0;
 	const view_1 = requireView();
-	const frame_1 = frame$1;
+	const frame_1 = frame;
 	const window_1 = requireWindow();
-	const external_application_1 = externalApplication$1;
+	const external_application_1 = externalApplication;
 	exports.environmentUnsupportedMessage = 'You are not running in OpenFin.';
 	function getBaseMe(entityType, uuid, name) {
 	    const entityTypeHelpers = {
@@ -13445,7 +13643,7 @@ var me = {};
 	            };
 	    }
 	}
-	exports.getMe = getMe; 
+	exports.getMe = getMe;
 } (me));
 
 var interop = {};
@@ -13548,8 +13746,9 @@ function requireSessionContextGroupBroker () {
 	        this.lastContext = context;
 	        const clientSubscriptionStates = Array.from(this.clients.values());
 	        clientSubscriptionStates.forEach((client) => {
+	            var _a;
 	            // eslint-disable-next-line no-unused-expressions
-	            client.contextHandlers.get(context.type)?.forEach((handlerId) => {
+	            (_a = client.contextHandlers.get(context.type)) === null || _a === void 0 ? void 0 : _a.forEach((handlerId) => {
 	                this.provider.dispatch(client.clientIdentity, handlerId, context);
 	            });
 	            if (client.globalHandler) {
@@ -13683,7 +13882,7 @@ var utils$1 = {};
 	        }
 	    };
 	};
-	exports.wrapIntentHandler = wrapIntentHandler; 
+	exports.wrapIntentHandler = wrapIntentHandler;
 } (utils$1));
 
 var PrivateChannelProvider = {};
@@ -13978,7 +14177,7 @@ function requireInteropBroker () {
 	hasRequiredInteropBroker = 1;
 	Object.defineProperty(InteropBroker, "__esModule", { value: true });
 	InteropBroker.InteropBroker = void 0;
-	const base_1 = base$1;
+	const base_1 = base;
 	const SessionContextGroupBroker_1 = requireSessionContextGroupBroker();
 	const utils_1 = utils$1;
 	const lodash_1 = require$$3;
@@ -14156,10 +14355,10 @@ function requireInteropBroker () {
 	        this.getProvider = getProvider;
 	        this.interopClients = new Map();
 	        this.contextGroupsById = new Map();
-	        if (options?.contextGroups) {
+	        if (options === null || options === void 0 ? void 0 : options.contextGroups) {
 	            contextGroups = options.contextGroups;
 	        }
-	        if (options?.logging) {
+	        if (options === null || options === void 0 ? void 0 : options.logging) {
 	            this.logging = options.logging;
 	        }
 	        this.intentClientMap = new Map();
@@ -14294,17 +14493,18 @@ function requireInteropBroker () {
 	     *
 	     */
 	    getCurrentContext(getCurrentContextOptions, clientIdentity) {
+	        var _a;
 	        this.wire.sendAction('interop-broker-get-current-context').catch((e) => {
 	            // don't expose, analytics-only call
 	        });
 	        const clientState = this.getClientState(clientIdentity);
-	        if (!clientState?.contextGroupId) {
+	        if (!(clientState === null || clientState === void 0 ? void 0 : clientState.contextGroupId)) {
 	            throw new Error('You must be a member of a context group to call getCurrentContext');
 	        }
 	        const { contextGroupId } = clientState;
 	        const contextGroupState = this.contextGroupsById.get(contextGroupId);
 	        const lastContextType = this.lastContextMap.get(contextGroupId);
-	        const contextType = getCurrentContextOptions?.contextType ?? lastContextType;
+	        const contextType = (_a = getCurrentContextOptions === null || getCurrentContextOptions === void 0 ? void 0 : getCurrentContextOptions.contextType) !== null && _a !== void 0 ? _a : lastContextType;
 	        return contextGroupState && contextType ? contextGroupState.get(contextType) : undefined;
 	    }
 	    /*
@@ -14955,9 +15155,10 @@ function requireInteropBroker () {
 	    }
 	    // Used to restore interop broker state in snapshots.
 	    applySnapshot(snapshot, options) {
-	        const contextGroupStates = snapshot?.interopSnapshotDetails?.contextGroupStates;
+	        var _a;
+	        const contextGroupStates = (_a = snapshot === null || snapshot === void 0 ? void 0 : snapshot.interopSnapshotDetails) === null || _a === void 0 ? void 0 : _a.contextGroupStates;
 	        if (contextGroupStates) {
-	            if (!options?.closeExistingWindows) {
+	            if (!(options === null || options === void 0 ? void 0 : options.closeExistingWindows)) {
 	                this.updateExistingClients(contextGroupStates);
 	            }
 	            this.rehydrateContextGroupStates(contextGroupStates);
@@ -15008,7 +15209,7 @@ function requireInteropBroker () {
 	    contextHandlerRegistered({ contextType, handlerId }, clientIdentity) {
 	        const handlerInfo = { contextType, handlerId };
 	        const clientState = this.getClientState(clientIdentity);
-	        clientState?.contextHandlers.set(handlerId, handlerInfo);
+	        clientState === null || clientState === void 0 ? void 0 : clientState.contextHandlers.set(handlerId, handlerInfo);
 	        if (clientState && clientState.contextGroupId) {
 	            const { contextGroupId } = clientState;
 	            const contextGroupMap = this.contextGroupsById.get(contextGroupId);
@@ -15030,7 +15231,7 @@ function requireInteropBroker () {
 	    async intentHandlerRegistered(payload, clientIdentity) {
 	        const { handlerId } = payload;
 	        const clientIntentInfo = this.intentClientMap.get(clientIdentity.name);
-	        const handlerInfo = clientIntentInfo?.get(handlerId);
+	        const handlerInfo = clientIntentInfo === null || clientIntentInfo === void 0 ? void 0 : clientIntentInfo.get(handlerId);
 	        if (!clientIntentInfo) {
 	            this.intentClientMap.set(clientIdentity.name, new Map());
 	            const newHandlerInfoMap = this.intentClientMap.get(clientIdentity.name);
@@ -15199,8 +15400,8 @@ function requireInteropBroker () {
 	                clientIdentity
 	            };
 	            // Only allow the client to join a contextGroup that actually exists.
-	            if (payload?.currentContextGroup && this.contextGroupsById.has(payload.currentContextGroup)) {
-	                clientSubscriptionState.contextGroupId = payload?.currentContextGroup;
+	            if ((payload === null || payload === void 0 ? void 0 : payload.currentContextGroup) && this.contextGroupsById.has(payload.currentContextGroup)) {
+	                clientSubscriptionState.contextGroupId = payload === null || payload === void 0 ? void 0 : payload.currentContextGroup;
 	            }
 	            this.interopClients.set(clientIdentity.endpointId, clientSubscriptionState);
 	        });
@@ -15218,15 +15419,17 @@ function requireInteropBroker () {
 	            this.clientDisconnected(clientIdentity);
 	        });
 	        channel.beforeAction(async (action, payload, clientIdentity) => {
+	            var _a, _b;
 	            if (!(await this.isActionAuthorized(action, payload, clientIdentity))) {
 	                throw new Error(`Action (${action}) not authorized for ${clientIdentity.uuid}, ${clientIdentity.name}`);
 	            }
-	            if (this.logging?.beforeAction?.enabled) {
+	            if ((_b = (_a = this.logging) === null || _a === void 0 ? void 0 : _a.beforeAction) === null || _b === void 0 ? void 0 : _b.enabled) {
 	                console.log(action, payload, clientIdentity);
 	            }
 	        });
 	        channel.afterAction((action, payload, clientIdentity) => {
-	            if (this.logging?.afterAction?.enabled) {
+	            var _a, _b;
+	            if ((_b = (_a = this.logging) === null || _a === void 0 ? void 0 : _a.afterAction) === null || _b === void 0 ? void 0 : _b.enabled) {
 	                console.log(action, payload, clientIdentity);
 	            }
 	        });
@@ -15308,7 +15511,7 @@ var __classPrivateFieldGet$3 = (commonjsGlobal && commonjsGlobal.__classPrivateF
 };
 var _SessionContextGroupClient_clientPromise;
 Object.defineProperty(SessionContextGroupClient$1, "__esModule", { value: true });
-const base_1$3 = base$1;
+const base_1$3 = base;
 const utils_1$3 = utils$1;
 class SessionContextGroupClient extends base_1$3.Base {
     constructor(wire, client, id) {
@@ -15395,7 +15598,7 @@ var __classPrivateFieldGet$2 = (commonjsGlobal && commonjsGlobal.__classPrivateF
 var _InteropClient_clientPromise, _InteropClient_sessionContextGroups;
 Object.defineProperty(InteropClient$1, "__esModule", { value: true });
 InteropClient$1.InteropClient = void 0;
-const base_1$2 = base$1;
+const base_1$2 = base;
 const SessionContextGroupClient_1 = SessionContextGroupClient$1;
 const utils_1$2 = utils$1;
 /**
@@ -16064,45 +16267,39 @@ class InteropClient extends base_1$2.Base {
 InteropClient$1.InteropClient = InteropClient;
 _InteropClient_clientPromise = new WeakMap(), _InteropClient_sessionContextGroups = new WeakMap();
 
-var overrideCheck = {};
+var overrideCheck$1 = {};
 
-var hasRequiredOverrideCheck;
-
-function requireOverrideCheck () {
-	if (hasRequiredOverrideCheck) return overrideCheck;
-	hasRequiredOverrideCheck = 1;
-	Object.defineProperty(overrideCheck, "__esModule", { value: true });
-	overrideCheck.overrideCheck = overrideCheck.getDefaultViewFdc3VersionFromAppInfo = void 0;
-	const InteropBroker_1 = requireInteropBroker();
-	function getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {
-	    const setVersion = manifest.platform?.defaultViewOptions?.fdc3InteropApi ?? initialOptions.defaultViewOptions?.fdc3InteropApi;
-	    return ['1.2', '2.0'].includes(setVersion ?? '') ? setVersion : undefined;
-	}
-	overrideCheck.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;
-	// TODO: Unit test this
-	function overrideCheck$1(overriddenBroker, fdc3InteropApi) {
-	    if (fdc3InteropApi && fdc3InteropApi === '2.0') {
-	        const mustOverrideAPIs = [
-	            'fdc3HandleFindInstances',
-	            'handleInfoForIntent',
-	            'handleInfoForIntentsByContext',
-	            'fdc3HandleGetAppMetadata',
-	            'fdc3HandleGetInfo',
-	            'fdc3HandleOpen',
-	            'handleFiredIntent',
-	            'handleFiredIntentForContext'
-	        ];
-	        const notOverridden = mustOverrideAPIs.filter((api) => {
-	            return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];
-	        });
-	        if (notOverridden.length > 0) {
-	            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\nThe following APIs need to be overridden:\n${notOverridden.join('\n')}`);
-	        }
-	    }
-	}
-	overrideCheck.overrideCheck = overrideCheck$1;
-	return overrideCheck;
+Object.defineProperty(overrideCheck$1, "__esModule", { value: true });
+overrideCheck$1.overrideCheck = overrideCheck$1.getDefaultViewFdc3VersionFromAppInfo = void 0;
+const InteropBroker_1 = requireInteropBroker();
+function getDefaultViewFdc3VersionFromAppInfo({ manifest, initialOptions }) {
+    var _a, _b, _c, _d;
+    const setVersion = (_c = (_b = (_a = manifest.platform) === null || _a === void 0 ? void 0 : _a.defaultViewOptions) === null || _b === void 0 ? void 0 : _b.fdc3InteropApi) !== null && _c !== void 0 ? _c : (_d = initialOptions.defaultViewOptions) === null || _d === void 0 ? void 0 : _d.fdc3InteropApi;
+    return ['1.2', '2.0'].includes(setVersion !== null && setVersion !== void 0 ? setVersion : '') ? setVersion : undefined;
+}
+overrideCheck$1.getDefaultViewFdc3VersionFromAppInfo = getDefaultViewFdc3VersionFromAppInfo;
+// TODO: Unit test this
+function overrideCheck(overriddenBroker, fdc3InteropApi) {
+    if (fdc3InteropApi && fdc3InteropApi === '2.0') {
+        const mustOverrideAPIs = [
+            'fdc3HandleFindInstances',
+            'handleInfoForIntent',
+            'handleInfoForIntentsByContext',
+            'fdc3HandleGetAppMetadata',
+            'fdc3HandleGetInfo',
+            'fdc3HandleOpen',
+            'handleFiredIntent',
+            'handleFiredIntentForContext'
+        ];
+        const notOverridden = mustOverrideAPIs.filter((api) => {
+            return overriddenBroker[api] === InteropBroker_1.InteropBroker.prototype[api];
+        });
+        if (notOverridden.length > 0) {
+            console.warn(`WARNING: FDC3 2.0 has been set as a default option for Views in this Platform, but the required InteropBroker APIs for FDC3 2.0 compliance have not all been overridden.\nThe following APIs need to be overridden:\n${notOverridden.join('\n')}`);
+        }
+    }
 }
+overrideCheck$1.overrideCheck = overrideCheck;
 
 var hasRequiredFactory;
 
@@ -16113,10 +16310,10 @@ function requireFactory () {
 	Factory$1.InteropModule = void 0;
 	const lodash_1 = require$$3;
 	const inaccessibleObject_1 = inaccessibleObject;
-	const base_1 = base$1;
+	const base_1 = base;
 	const InteropBroker_1 = requireInteropBroker();
 	const InteropClient_1 = InteropClient$1;
-	const overrideCheck_1 = requireOverrideCheck();
+	const overrideCheck_1 = overrideCheck$1;
 	const common_utils_1 = commonUtils;
 	const defaultOverride = (Class) => new Class();
 	const BrokerParamAccessError = 'You have attempted to use or modify InteropBroker parameters, which is not allowed. You are likely using an older InteropBroker override scheme. Please consult our Interop docs for guidance on migrating to the new override scheme.';
@@ -16149,12 +16346,13 @@ function requireFactory () {
 	     * ```
 	     */
 	    async init(name, override = defaultOverride) {
+	        var _a;
 	        this.wire.sendAction('interop-init').catch(() => {
 	            // don't expose, analytics-only call
 	        });
 	        // Allows for manifest-level configuration, without having to override. (e.g. specifying custom context groups)
 	        const options = await this.fin.Application.getCurrentSync().getInfo();
-	        const opts = options.initialOptions.interopBrokerConfiguration ?? {};
+	        const opts = (_a = options.initialOptions.interopBrokerConfiguration) !== null && _a !== void 0 ? _a : {};
 	        const objectThatThrows = (0, inaccessibleObject_1.createUnusableObject)(BrokerParamAccessError);
 	        const warningOptsClone = (0, inaccessibleObject_1.createWarningObject)(BrokerParamAccessError, (0, lodash_1.cloneDeep)(opts));
 	        let provider;
@@ -16222,9 +16420,9 @@ function requireInterop () {
 	hasRequiredInterop = 1;
 	(function (exports) {
 		/**
-		 * Entry point for the OpenFin `Interop` API (`fin.Interop`).
+		 * Entry point for the OpenFin Interop namespace.
 		 *
-		 * * {@link InteropModule} contains static members of the `Interop` API (available under `fin.Interop`)
+		 * * {@link InteropModule} contains static members of the `Interop` namespace (available under `fin.Interop`)
 		 * * {@link InteropClient} and {@link InteropBroker} document instances of their respective classes.
 		 *
 		 * @packageDocumentation
@@ -16246,8 +16444,8 @@ function requireInterop () {
 		Object.defineProperty(exports, "__esModule", { value: true });
 		__exportStar(requireFactory(), exports);
 		__exportStar(InteropClient$1, exports);
-		__exportStar(requireInteropBroker(), exports); 
-	} (interop));
+		__exportStar(requireInteropBroker(), exports);
+} (interop));
 	return interop;
 }
 
@@ -16280,14 +16478,12 @@ var _SnapshotSource_identity, _SnapshotSource_getConnection, _SnapshotSource_get
 Object.defineProperty(Instance, "__esModule", { value: true });
 Instance.SnapshotSource = void 0;
 /* eslint-disable @typescript-eslint/no-non-null-assertion */
-const base_1$1 = base$1;
+const base_1$1 = base;
 const utils_1$1 = utils;
 const connectionMap = new Map();
 /**
  * Enables configuring a SnapshotSource with custom getSnapshot and applySnapshot methods.
  *
- * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows
- * custom snapshot implementations for legacy applications to define their own snapshot format.
  */
 class SnapshotSource extends base_1$1.Base {
     /**
@@ -16423,7 +16619,7 @@ _SnapshotSource_identity = new WeakMap(), _SnapshotSource_getConnection = new We
 
 Object.defineProperty(Factory, "__esModule", { value: true });
 Factory.SnapshotSourceModule = void 0;
-const base_1 = base$1;
+const base_1 = base;
 const Instance_1 = Instance;
 const utils_1 = utils;
 /**
@@ -16433,9 +16629,6 @@ class SnapshotSourceModule extends base_1.Base {
     /**
      * Initializes a SnapshotSource with the getSnapshot and applySnapshot methods defined.
      *
-     * @typeParam Snapshot Implementation-defined shape of an application snapshot.  Allows
-     * custom snapshot implementations for legacy applications to define their own snapshot format.
-     *
      * @example
      * ```js
      * const snapshotProvider = {
@@ -16451,7 +16644,6 @@ class SnapshotSourceModule extends base_1.Base {
      *
      * await fin.SnapshotSource.init(snapshotProvider);
      * ```
-     *
      */
     async init(provider) {
         this.wire.sendAction('snapshot-source-init').catch((e) => {
@@ -16506,9 +16698,9 @@ Factory.SnapshotSourceModule = SnapshotSourceModule;
 
 (function (exports) {
 	/**
-	 * Entry points for the OpenFin `SnapshotSource` API (`fin.SnapshotSource`).
+	 * Entry points for the OpenFin `SnapshotSource` API.
 	 *
-	 * * {@link SnapshotSourceModule} contains static members of the `SnapshotSource` API, accessible through `fin.SnapshotSource`.
+	 * * {@link SnapshotSourceModule} contains static methods relating to the `SnapshotSource` type, accessible through `fin.SnapshotSource`.
 	 * * {@link SnapshotSource} describes an instance of an OpenFin SnapshotSource, e.g. as returned by `fin.SnapshotSource.wrap`.
 	 *
 	 * These are separate code entities, and are documented separately.  In the [previous version of the API documentation](https://cdn.openfin.co/docs/javascript/canary/index.html),
@@ -16532,29 +16724,26 @@ Factory.SnapshotSourceModule = SnapshotSourceModule;
 	};
 	Object.defineProperty(exports, "__esModule", { value: true });
 	__exportStar(Factory, exports);
-	__exportStar(Instance, exports); 
+	__exportStar(Instance, exports);
 } (snapshotSource));
 
 Object.defineProperty(fin, "__esModule", { value: true });
 fin.Fin = void 0;
-const events_1$3 = require$$0;
+const events_1$3 = eventsExports;
 // Import from the file rather than the directory in case someone consuming types is using module resolution other than "node"
-const index_1 = system$1;
+const index_1 = system;
 const index_2 = requireWindow();
 const index_3 = requireApplication();
 const index_4 = interappbus;
 const index_5 = clipboard;
-const index_6 = externalApplication$1;
-const index_7 = frame$1;
-const index_8 = globalHotkey$1;
+const index_6 = externalApplication;
+const index_7 = frame;
+const index_8 = globalHotkey;
 const index_9 = requireView();
-const index_10 = platform$1;
+const index_10 = platform;
 const me_1$1 = me;
 const interop_1 = requireInterop();
 const snapshot_source_1 = snapshotSource;
-/**
- * @internal
- */
 class Fin extends events_1$3.EventEmitter {
     /**
      * @internal
@@ -16587,7 +16776,7 @@ fin.Fin = Fin;
 var wire = {};
 
 Object.defineProperty(wire, "__esModule", { value: true });
-wire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isConfigWithReceiver = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;
+wire.isInternalConnectConfig = wire.isPortDiscoveryConfig = wire.isNewConnectConfig = wire.isRemoteConfig = wire.isExistingConnectConfig = wire.isExternalConfig = void 0;
 function isExternalConfig(config) {
     if (typeof config.manifestUrl === 'string') {
         return true;
@@ -16603,10 +16792,6 @@ function isRemoteConfig(config) {
     return isExistingConnectConfig(config) && typeof config.token === 'string';
 }
 wire.isRemoteConfig = isRemoteConfig;
-function isConfigWithReceiver(config) {
-    return typeof config.receiver === 'object' && isRemoteConfig({ ...config, address: '' });
-}
-wire.isConfigWithReceiver = isConfigWithReceiver;
 function hasUuid(config) {
     return typeof config.uuid === 'string';
 }
@@ -16647,8 +16832,8 @@ var http = {};
 (function (exports) {
 	Object.defineProperty(exports, "__esModule", { value: true });
 	exports.fetchJson = exports.downloadFile = exports.fetch = exports.getRequestOptions = exports.getProxy = void 0;
-	const node_url_1 = require$$0$1; // This must explicitly use node builtin to avoid accidentally bundling npm:url.
-	const fs = require$$0$2;
+	const node_url_1 = require$$0; // This must explicitly use node builtin to avoid accidentally bundling npm:url.
+	const fs = require$$0$1;
 	const getProxyVar = () => {
 	    return process.env.HTTPS_PROXY || process.env.https_proxy || process.env.HTTP_PROXY || process.env.http_proxy;
 	};
@@ -16733,13 +16918,13 @@ var http = {};
 	    const res = await (0, exports.fetch)(url);
 	    return JSON.parse(res);
 	};
-	exports.fetchJson = fetchJson; 
+	exports.fetchJson = fetchJson;
 } (http));
 
 Object.defineProperty(util, "__esModule", { value: true });
 util.resolveDir = util.first = util.resolveRuntimeVersion = util.rmDir = util.unzip = util.exists = void 0;
-const path$1 = require$$0$3;
-const fs$1 = require$$0$2;
+const path$1 = require$$0$2;
+const fs$1 = require$$0$1;
 const child_process_1$1 = require$$2;
 const promises_1$1 = promises;
 const http_1$1 = http;
@@ -16841,7 +17026,7 @@ async function resolveDir(base, paths) {
 util.resolveDir = resolveDir;
 
 Object.defineProperty(winLaunch, "__esModule", { value: true });
-const path = require$$0$3;
+const path = require$$0$2;
 const child_process_1 = require$$2;
 const util_1 = util;
 function launchRVM(config, manifestLocation, namedPipeName, rvm) {
@@ -16863,7 +17048,7 @@ function launchRVM(config, manifestLocation, namedPipeName, rvm) {
 async function checkRvmPath() {
     let rvmPath = path.resolve(process.env.LOCALAPPDATA, 'OpenFin', 'OpenFinRVM.exe');
     if (!(await (0, util_1.exists)(rvmPath))) {
-        rvmPath = path.join(__dirname, '..', 'resources', 'win', 'OpenFinRVM.exe');
+        rvmPath = path.join(__dirname, '..', '..', 'resources', 'win', 'OpenFinRVM.exe');
     }
     return rvmPath;
 }
@@ -16925,8 +17110,8 @@ function requireServices () {
 		const startServices = async (services) => {
 		    await (0, promises_1.promiseMapSerial)(services, exports.launchService);
 		};
-		exports.startServices = startServices; 
-	} (services));
+		exports.startServices = startServices;
+} (services));
 	return services;
 }
 
@@ -16937,8 +17122,8 @@ function requireNixLaunch () {
 	hasRequiredNixLaunch = 1;
 	Object.defineProperty(nixLaunch, "__esModule", { value: true });
 	nixLaunch.install = nixLaunch.getRuntimePath = nixLaunch.download = nixLaunch.getUrl = void 0;
-	const fs = require$$0$2;
-	const path = require$$0$3;
+	const fs = require$$0$1;
+	const path = require$$0$2;
 	const child_process_1 = require$$2;
 	const promises_1 = promises;
 	const util_1 = util;
@@ -17045,8 +17230,8 @@ function requireLauncher () {
 	if (hasRequiredLauncher) return launcher;
 	hasRequiredLauncher = 1;
 	Object.defineProperty(launcher, "__esModule", { value: true });
-	const os = require$$0$4;
-	const path = require$$0$3;
+	const os = require$$0$3;
+	const path = require$$0$2;
 	const win_launch_1 = winLaunch;
 	const nix_launch_1 = requireNixLaunch();
 	class Launcher {
@@ -17121,10 +17306,10 @@ function requirePortDiscovery () {
 	hasRequiredPortDiscovery = 1;
 	Object.defineProperty(portDiscovery, "__esModule", { value: true });
 	/* eslint-disable @typescript-eslint/naming-convention */
-	const fs = require$$0$2;
+	const fs = require$$0$1;
 	const net = require$$1;
-	const path = require$$0$3;
-	const os = require$$0$4;
+	const path = require$$0$2;
+	const os = require$$0$3;
 	const timers_1 = require$$4;
 	const wire_1 = wire;
 	const launcher_1 = requireLauncher();
@@ -17399,17 +17584,12 @@ function requireNodeEnv () {
 	hasRequiredNodeEnv = 1;
 	Object.defineProperty(nodeEnv, "__esModule", { value: true });
 	/* eslint-disable class-methods-use-this */
-	const fs_1 = require$$0$2;
+	const fs_1 = require$$0$1;
 	const crypto_1 = require$$1$1;
-	const _WS = require$$2$1;
+	const WS = require$$2$1;
 	const environment_1 = environment;
 	const port_discovery_1 = requirePortDiscovery();
 	const transport_errors_1 = transportErrors;
-	// Due to https://github.com/rollup/rollup/issues/1267, we need this guard
-	// to ensure the import works with and without the 'esModuleInterop' ts flag.
-	// This is due to our mocha tests not being compatible with esModuleInterop,
-	// whereas rollup enforces it.
-	const WS = _WS.default || _WS;
 	class NodeEnvironment {
 	    constructor() {
 	        this.messageCounter = 0;
@@ -17484,7 +17664,7 @@ var emitterMap = {};
 
 Object.defineProperty(emitterMap, "__esModule", { value: true });
 emitterMap.EmitterMap = void 0;
-const events_1$2 = require$$0;
+const events_1$2 = eventsExports;
 class EmitterMap {
     constructor() {
         this.storage = new Map();
@@ -17566,7 +17746,7 @@ var __classPrivateFieldGet = (commonjsGlobal && commonjsGlobal.__classPrivateFie
 var _Transport_wire, _Transport_fin;
 Object.defineProperty(transport, "__esModule", { value: true });
 transport.Transport = void 0;
-const events_1$1 = require$$0;
+const events_1$1 = eventsExports;
 const wire_1$1 = wire;
 const transport_errors_1$1 = transportErrors;
 const eventAggregator_1 = eventAggregator;
@@ -17608,13 +17788,13 @@ class Transport extends events_1$1.EventEmitter {
     }
     getFin() {
         if (!__classPrivateFieldGet(this, _Transport_fin, "f")) {
-            throw new Error('No Fin object registered for this transport');
+            throw new Error("No Fin object registered for this transport");
         }
         return __classPrivateFieldGet(this, _Transport_fin, "f");
     }
     registerFin(_fin) {
         if (__classPrivateFieldGet(this, _Transport_fin, "f")) {
-            throw new Error('Fin object has already been registered for this transport');
+            throw new Error("Fin object has already been registered for this transport");
         }
         __classPrivateFieldSet(this, _Transport_fin, _fin, "f");
     }
@@ -17623,10 +17803,6 @@ class Transport extends events_1$1.EventEmitter {
         return wire.shutdown();
     }
     async connect(config) {
-        if ((0, wire_1$1.isConfigWithReceiver)(config)) {
-            await __classPrivateFieldGet(this, _Transport_wire, "f").connect(config.receiver);
-            return this.authorize(config);
-        }
         if ((0, wire_1$1.isRemoteConfig)(config)) {
             return this.connectRemote(config);
         }
@@ -17640,14 +17816,14 @@ class Transport extends events_1$1.EventEmitter {
         return undefined;
     }
     async connectRemote(config) {
-        await __classPrivateFieldGet(this, _Transport_wire, "f").connect(new (this.environment.getWsConstructor())(config.address));
+        await __classPrivateFieldGet(this, _Transport_wire, "f").connect(config.address, this.environment.getWsConstructor());
         return this.authorize(config);
     }
     async connectByPort(config) {
         const { address, uuid } = config;
         const reqAuthPayload = { ...config, type: 'file-token' };
         const wire = __classPrivateFieldGet(this, _Transport_wire, "f");
-        await wire.connect(new (this.environment.getWsConstructor())(config.address));
+        await wire.connect(address, this.environment.getWsConstructor());
         const requestExtAuthRet = await this.sendAction('request-external-authorization', {
             uuid,
             type: 'file-token'
@@ -17667,9 +17843,7 @@ class Transport extends events_1$1.EventEmitter {
             throw new transport_errors_1$1.RuntimeError(requestAuthRet.payload);
         }
     }
-    sendAction(action, payload = {}, uncorrelated = false
-    // specialResponse type is only used for 'requestAuthorization'
-    ) {
+    sendAction(action, payload = {}, uncorrelated = false) {
         // eslint-disable-next-line @typescript-eslint/no-empty-function
         let cancel = () => { };
         // We want the callsite from the caller of this function, not from here.
@@ -17719,10 +17893,7 @@ class Transport extends events_1$1.EventEmitter {
             this.uncorrelatedListener = resolve;
         }
         else if (this.wireListeners.has(id)) {
-            handleNack({
-                reason: 'Duplicate handler id',
-                error: (0, errors_1.errorToPOJO)(new transport_errors_1$1.DuplicateCorrelationError(String(id)))
-            });
+            handleNack({ reason: 'Duplicate handler id', error: (0, errors_1.errorToPOJO)(new transport_errors_1$1.DuplicateCorrelationError(String(id))) });
         }
         else {
             this.wireListeners.set(id, { resolve, handleNack });
@@ -17782,19 +17953,9 @@ _Transport_wire = new WeakMap(), _Transport_fin = new WeakMap();
 
 var websocket = {};
 
-var messageReceiver = {};
-
-Object.defineProperty(messageReceiver, "__esModule", { value: true });
-messageReceiver.isOpen = void 0;
-function isOpen(receiver) {
-    return receiver.readyState === 'open' || receiver.readyState === 1;
-}
-messageReceiver.isOpen = isOpen;
-
 Object.defineProperty(websocket, "__esModule", { value: true });
-const events_1 = require$$0;
+const events_1 = eventsExports;
 const transport_errors_1 = transportErrors;
-const messageReceiver_1 = messageReceiver;
 /* `READY_STATE` is an instance var set by `constructor` to reference the `WebTransportSocket.READY_STATE` enum.
  * This is syntactic sugar that makes the enum accessible through the `wire` property of the various `fin` singletons.
  * For example, `fin.system.wire.READY_STATE` is a shortcut to `fin.system.wire.wire.constructor.READY_STATE`.
@@ -17812,18 +17973,15 @@ var READY_STATE;
 class WebSocketTransport extends events_1.EventEmitter {
     constructor(onmessage) {
         super();
-        this.connect = (messageReceiver) => {
+        this.connect = (address, WsConstructor) => {
             return new Promise((resolve, reject) => {
-                this.wire = messageReceiver;
-                this.wire.addEventListener('open', () => resolve());
+                this.wire = new WsConstructor(address);
+                this.wire.addEventListener('open', resolve);
                 this.wire.addEventListener('error', reject);
                 this.wire.addEventListener('message', (message) => this.onmessage.call(null, JSON.parse(message.data)));
                 this.wire.addEventListener('close', () => {
                     this.emit('disconnected');
                 });
-                if ((0, messageReceiver_1.isOpen)(this.wire)) {
-                    resolve();
-                }
             });
         };
         this.connectSync = () => {
@@ -17833,7 +17991,7 @@ class WebSocketTransport extends events_1.EventEmitter {
     }
     send(data, flags) {
         return new Promise((resolve, reject) => {
-            if (!(0, messageReceiver_1.isOpen)(this.wire)) {
+            if (this.wire.readyState !== READY_STATE.OPEN) {
                 reject(new transport_errors_1.DisconnectedError(READY_STATE[this.wire.readyState]));
             }
             else {
@@ -17847,7 +18005,6 @@ class WebSocketTransport extends events_1.EventEmitter {
         return Promise.resolve();
     }
     getPort() {
-        // @ts-expect-error
         return this.wire.url.split(':').slice(-1)[0];
     }
 }
@@ -17857,8 +18014,8 @@ var normalizeConfig$1 = {};
 
 Object.defineProperty(normalizeConfig$1, "__esModule", { value: true });
 normalizeConfig$1.validateConfig = normalizeConfig$1.normalizeConfig = void 0;
-const fs = require$$0$2;
-const node_url_1 = require$$0$1; // This must explicitly use node builtin to avoid accidentally bundling npm:url
+const fs = require$$0$1;
+const node_url_1 = require$$0; // This must explicitly use node builtin to avoid accidentally bundling npm:url
 const wire_1 = wire;
 const promises_1 = promises;
 const http_1 = http;
@@ -17927,9 +18084,9 @@ function requireMain () {
 		Object.defineProperty(exports, "ChannelClient", { enumerable: true, get: function () { return client_1.ChannelClient; } });
 		const provider_1 = provider;
 		Object.defineProperty(exports, "ChannelProvider", { enumerable: true, get: function () { return provider_1.ChannelProvider; } });
-		const frame_1 = frame$1;
+		const frame_1 = frame;
 		Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return frame_1._Frame; } });
-		const system_1 = system$1;
+		const system_1 = system;
 		Object.defineProperty(exports, "System", { enumerable: true, get: function () { return system_1.System; } });
 		const wire_1 = wire;
 		const node_env_1 = requireNodeEnv();
@@ -17940,10 +18097,11 @@ function requireMain () {
 		const environment = new node_env_1.default();
 		// Connect to an OpenFin Runtime
 		async function connect(config) {
+		    var _a;
 		    const normalized = await (0, normalize_config_1.validateConfig)(config);
 		    const wire = new transport_1.Transport(websocket_1.default, environment, {
 		        ...normalized,
-		        name: normalized.name ?? normalized.uuid
+		        name: (_a = normalized.name) !== null && _a !== void 0 ? _a : normalized.uuid
 		    });
 		    await wire.connect(normalized);
 		    return new fin_1.Fin(wire);
@@ -17957,268 +18115,22 @@ function requireMain () {
 		    const pd = new port_discovery_1.default(normalized, environment);
 		    return pd.retrievePort();
 		}
-		exports.launch = launch; 
-	} (main$1));
+		exports.launch = launch;
+} (main$1));
 	return main$1;
 }
 
 var mainExports = requireMain();
 
-var OpenFin$2 = {};
-
-var events = {};
-
-var application = {};
-
-/**
- * Namespace for events that can be emitted by an {@link OpenFin.Application}.  Includes events
- * re-propagated from the {@link OpenFin.Window} (and, transitively, {@link OpenFin.View}) level, prefixed with `window-` (and also, if applicable, `view-`).
- * For example, a view's "attached" event will fire as 'window-view-attached' at the application level.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * This namespace contains only payload shapes for events that are unique to `Application`.  Events that propagate to `Application` from
- * child {@link OpenFin.Window windows} and {@link OpenFin.View views} are defined in the {@link OpenFin.WindowEvents} and
- * {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all* application events, see {@link Application.on Application.on}.
- *
- * {@link ApplicationSourcedEvent Application-sourced events} (i.e. those that have not propagated from {@link OpenFin.ViewEvents Views}
- * or {@link OpenFin.WindowEvents Windows} re-propagate to {@link OpenFin.SystemEvents System} with their type string prefixed with `application-`.
- * {@link ApplicationWindowEvent Application events that are tied to Windows but do not propagate from them}
- * are propagated to `System` without any type string prefixing.
- *
- * "Requested" events (e.g. {@link RunRequestedEvent}) do not propagate.
- *
- * @packageDocumentation
- */
-Object.defineProperty(application, "__esModule", { value: true });
-
-var base = {};
-
-/**
- * Namespace for shared event payloads and utility types common to all event emitters.
- *
- * @packageDocumentation
- */
-Object.defineProperty(base, "__esModule", { value: true });
-
-var externalApplication = {};
-
-/**
- * Namespace for events that can be transmitted by an {@link OpenFin.ExternalApplication}.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * For a list of valid string keys for external application events, see {@link ExternalApplication.on ExternalApplication.on}.
- *
- * @packageDocumentation
- */
-Object.defineProperty(externalApplication, "__esModule", { value: true });
-
-var frame = {};
-
-Object.defineProperty(frame, "__esModule", { value: true });
-
-var globalHotkey = {};
-
-Object.defineProperty(globalHotkey, "__esModule", { value: true });
-
-var platform = {};
-
-/**
- *
- * Namespace for events that can emitted by a {@link OpenFin.Platform}.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * The Platform `EventEmitter` is a superset of the {@link OpenFin.Application} `EventEmitter`,
- * meaning it can listen to all {@link OpenFin.ApplicationEvents Application events} in addition to the
- * Platform-specific events listed here.  For a list of valid string keys for *all* platform events, see
- * {@link Platform.on Platform.on}.
- *
- * @packageDocumentation
- */
-Object.defineProperty(platform, "__esModule", { value: true });
-
-var system = {};
-
-/**
- * Namespace for runtime-wide OpenFin events emitted by {@link System.System}.  Includes events
- * re-propagated from {@link OpenFin.Application}, {@link OpenFin.Window}, and {@link OpenFin.View} (prefixed with `application-`, `window-`, and `view-`).  All
- * event propagations are visible at the System level. Propagated events from WebContents (windows, views, frames) to the Application level will *not*
- * transitively re-propagate to the System level, because they are already visible at the system level and contain the identity
- * of the application.  For example, an application's "closed" event will fire as 'application-closed' at the system level.  A view's 'shown' event
- * will be visible as 'view-shown' at the system level, but *not* as `application-window-view-shown`.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * This namespace contains only payload shapes for events that are unique to `System`.  Events that propagate to `System` from
- * child {@link OpenFin.Application applications}, {@link OpenFin.Window windows}, and {@link OpenFin.View views} are defined in the
- * {@link OpenFin.ApplicationEvents}, {@link OpenFin.WindowEvents}, and {@link OpenFin.ViewEvents} namespaces.  For a list of valid string keys for *all*
- * system events, see {@link System.on System.on}.
- *
- * @packageDocumentation
- */
-Object.defineProperty(system, "__esModule", { value: true });
-
-var view = {};
-
-/**
- * Namespace for events that can be emitted by a {@link OpenFin.View}.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * This namespace contains only payload shapes for events that are unique to `View`.  Events that are shared between all `WebContents`
- * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}.  For a list
- * of valid string keys for *all* View events, see {@link View.on View.on}.
- *
- * View events propagate to their parent {@link OpenFin.WindowEvents Window}, {@link OpenFin.ApplicationEvents Application},
- * and {@link OpenFin.SystemEvents System} with an added `viewIdentity` property and their event types prefixed with `'view-'`.
- *
- * @packageDocumentation
- */
-Object.defineProperty(view, "__esModule", { value: true });
-
-var webcontents = {};
-
-/**
- * Namespace for events shared by all OpenFin WebContents elements (i.e. {@link OpenFin.Window},
- * {@link OpenFin.View}).
- *
- * WebContents events are divided into two groups: {@link WillPropagateWebContentsEvent} and {@link NonPropagatedWebContentsEvent}.  Propagating events
- * will re-emit on parent entities - e.g., a propagating event in a view will also be emitted on the view's
- * parent window, and propagating events in a window will also be emitted on the window's parent {@link OpenFin.Application}.
- *
- * Non-propagating events will not re-emit on parent entities.
- *
- * @packageDocumentation
- */
-Object.defineProperty(webcontents, "__esModule", { value: true });
-
-var window$1 = {};
-
-/**
- * Namespace for events that can be emitted by a {@link OpenFin.Window}.
- *
- * Event payloads are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * This namespace contains only payload shapes for events that are unique to `Window`.  Events that are shared between all `WebContents`
- * (i.e. {@link OpenFin.Window}, {@link OpenFin.View}) are defined in {@link OpenFin.WebContentsEvents}. Events that
- * propagate from `View` are defined in {@link OpenFin.ViewEvents}. For a list of valid string keys for *all* Window events, see
- * {@link Window.on Window.on}
- *
- * {@link OpenFin.WindowEvents.WindowSourcedEvent Window-sourced events} (i.e. those that are not propagated from a
- * {@link OpenFin.ViewEvents View}) propagate to their parent {@link OpenFin.ApplicationEvents Application} and
- * {@link OpenFin.SystemEvents System} with their event types prefixed with `'window-'`).
- *
- * "Requested" events (e.g. {@link AuthRequestedEvent}) do not propagate to `System.  The {@link OpenFin.WindowEvents.WindowCloseRequestedEvent}
- * does not propagate at all.
- *
- * @packageDocumentation
- */
-Object.defineProperty(window$1, "__esModule", { value: true });
-
-/**
- * Namespace for OpenFin event types. Each entity that emits OpenFin events has its own sub-namespace. Event payloads
- * themselves are documented as interfaces, while algebraic helper types and derived types are documented as type aliases.
- *
- * #### Event emitters
- *
- * The following entities emit OpenFin events, and have corresponding sub-namespaces:
- *
- * * {@link OpenFin.Application}: {@link OpenFin.ApplicationEvents}
- * * {@link OpenFin.ExternalApplication}: {@link OpenFin.ExternalApplicationEvents}
- * * {@link OpenFin.Frame}: {@link OpenFin.FrameEvents}
- * * {@link OpenFin.GlobalHotkey}: {@link OpenFin.GlobalHotkeyEvents}
- * * {@link OpenFin.Platform}: {@link OpenFin.PlatformEvents}
- * * {@link OpenFin.System}: {@link OpenFin.SystemEvents}
- * * {@link OpenFin.View}: {@link OpenFin.ViewEvents}
- * * {@link OpenFin.Window}: {@link OpenFin.WindowEvents}
- *
- * These `EventEmitter` entities share a common set of methods for interacting with the OpenFin event bus, which can be
- * seen on the individual documentation pages for each entity type.
- *
- * Registering event handlers is an asynchronous operation. It is important to ensure that the returned Promises are awaited to reduce the
- * risk of race conditions.
- *
- * When the `EventEmitter` receives an event from the browser process and emits on the renderer, all of the functions attached to that
- * specific event are called synchronously. Any values returned by the called listeners are ignored and will be discarded.  If the window document
- * is destroyed by page navigation or reload, its registered event listeners will be removed.
- *
- * We recommend using Arrow Functions for event listeners to ensure the this scope is consistent with the original function context.
- *
- * Events re-propagate from smaller/more-local scopes to larger/more-global scopes.  For example, an event emitted on a specific
- * view will propagate to the window in which the view is embedded, and then to the application in which the window is running, and
- * finally to the OpenFin runtime itself at the "system" level.  For details on propagation semantics, see the namespace for
- * the propagating (or propagated-to) entity.
- *
- * If you need the payload type for a specific type of event (especially propagated events), use the emitting topic's `Payload` generic
- * (e.g. {@link WindowEvents.Payload}) with the event's `type` string.  For example, the payload of
- * a {@link ViewEvents.CreatedEvent} after it has propagated to its parent {@link WindowEvents Window} can be found with
- * `WindowEvents.Payload<'view-created'>`.
- *
- * @packageDocumentation
- */
-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;
-events.ApplicationEvents = ApplicationEvents;
-const BaseEvents = base;
-events.BaseEvents = BaseEvents;
-const ExternalApplicationEvents = externalApplication;
-events.ExternalApplicationEvents = ExternalApplicationEvents;
-const FrameEvents = frame;
-events.FrameEvents = FrameEvents;
-const GlobalHotkeyEvents = globalHotkey;
-events.GlobalHotkeyEvents = GlobalHotkeyEvents;
-const PlatformEvents = platform;
-events.PlatformEvents = PlatformEvents;
-const SystemEvents = system;
-events.SystemEvents = SystemEvents;
-const ViewEvents = view;
-events.ViewEvents = ViewEvents;
-const WebContentsEvents = webcontents;
-events.WebContentsEvents = WebContentsEvents;
-const WindowEvents = window$1;
-events.WindowEvents = WindowEvents;
-
-(function (exports) {
-	/**
-	 * Top-level namespace for types referenced by the OpenFin API.  Contains:
-	 *
-	 * * The type of the global `fin` entry point ({@link FinApi})
-	 * * Classes that act as static namespaces returned from the `fin` global (e.g. {@link ApplicationModule}, accessible via `fin.Application`)
-	 * * Instance classes that are returned from API calls (e.g. {@link Application}, accessible via `fin.Application.getCurrentSync()`)
-	 * * Parameter shapes for API methods (e.g. {@link ApplicationOptions}, used in `fin.Application.start()`)
-	 * * Event namespaces and payload union types (e.g. {@link ApplicationEvents} and {@link ApplicationEvent})
-	 *
-	 * @packageDocumentation
-	 */
-	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 });
-	// Deprecated shim to preserve v30 namespace names
-	__exportStar(events, exports); 
-} (OpenFin$2));
+var OpenFin$1 = {};
 
-var OpenFin = /*@__PURE__*/getDefaultExportFromCjs(OpenFin$2);
+Object.defineProperty(OpenFin$1, "__esModule", { value: true });
 
-var OpenFin$1 = /*#__PURE__*/_mergeNamespaces({
+var OpenFin = /*#__PURE__*/_mergeNamespaces({
 	__proto__: null,
-	default: OpenFin
-}, [OpenFin$2]);
+	default: OpenFin$1
+}, [OpenFin$1]);
 
 exports.connect = mainExports.connect;
-exports.default = OpenFin$1;
+exports.default = OpenFin;
 exports.launch = mainExports.launch;