@openfin/node-adapter 38.81.41 → 38.81.42

package/out/node-adapter.js

@@ -86,7 +86,7 @@ var __classPrivateFieldGet$e = (commonjsGlobal && commonjsGlobal.__classPrivateF
 var _EmitterBase_emitterAccessor;
 Object.defineProperty(base$1, "__esModule", { value: true });
 base$1.Reply = base$1.EmitterBase = base$1.Base = void 0;
-const promises_1$2 = promises;
+const promises_1$3 = promises;
 class Base {
     /**
      * @internal
@@ -316,7 +316,7 @@ class EmitterBase extends Base {
         }
         else if (this.hasEmitter()) {
             const events = this.getOrCreateEmitter().eventNames();
-            await (0, promises_1$2.promiseMap)(events, removeByEvent);
+            await (0, promises_1$3.promiseMap)(events, removeByEvent);
         }
         return this;
     }
@@ -5633,7 +5633,7 @@ function requireWindow () {
 Object.defineProperty(system$1, "__esModule", { value: true });
 system$1.System = void 0;
 const base_1$i = base$1;
-const transport_errors_1$2 = transportErrors;
+const transport_errors_1$3 = transportErrors;
 const window_1 = requireWindow();
 const events_1$6 = require$$0;
 /**
@@ -6711,9 +6711,9 @@ class System extends base_1$i.EmitterBase {
         });
         // node.js environment not supported
         if (this.wire.environment.type !== 'openfin') {
-            throw new transport_errors_1$2.NotSupportedError('downloadAsset only supported in an OpenFin Render process');
+            throw new transport_errors_1$3.NotSupportedError('downloadAsset only supported in an OpenFin Render process');
         }
-        const callSite = transport_errors_1$2.RuntimeError.getCallSite();
+        const callSite = transport_errors_1$3.RuntimeError.getCallSite();
         const downloadId = this.wire.environment.getNextMessageId().toString();
         const dlProgressKey = `asset-download-progress-${downloadId}`;
         const dlErrorKey = `asset-download-error-${downloadId}`;
@@ -6733,7 +6733,7 @@ class System extends base_1$i.EmitterBase {
         const dlError = (payload) => {
             cleanListeners();
             const { reason, err: error } = payload;
-            reject(new transport_errors_1$2.RuntimeError({ reason, error }, callSite));
+            reject(new transport_errors_1$3.RuntimeError({ reason, error }, callSite));
         };
         const dlComplete = () => {
             cleanListeners();
@@ -6784,11 +6784,11 @@ class System extends base_1$i.EmitterBase {
      * ```
      */
     downloadRuntime(options, progressListener) {
-        const callsites = transport_errors_1$2.RuntimeError.getCallSite();
+        const callsites = transport_errors_1$3.RuntimeError.getCallSite();
         return new Promise((resolve, reject) => {
             // node.js environment not supported
             if (this.wire.environment.type !== 'openfin') {
-                reject(new transport_errors_1$2.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));
+                reject(new transport_errors_1$3.NotSupportedError('downloadRuntime only supported in an OpenFin Render process'));
                 return;
             }
             const downloadId = this.wire.environment.getNextMessageId().toString();
@@ -6810,7 +6810,7 @@ class System extends base_1$i.EmitterBase {
             const dlError = (payload) => {
                 cleanListeners();
                 const { reason, err: error } = payload;
-                reject(new transport_errors_1$2.RuntimeError({ reason, error }, callsites));
+                reject(new transport_errors_1$3.RuntimeError({ reason, error }, callsites));
             };
             const dlComplete = () => {
                 cleanListeners();
@@ -16717,7 +16717,7 @@ environment.notImplementedEnvErrorMsg = 'Not implemented in this environment';
 
 var portDiscovery = {};
 
-var launcher = {};
+var launcher$1 = {};
 
 var nixLaunch = {};
 
@@ -16832,12 +16832,12 @@ var 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$$1;
-const fs$1 = require$$0$2;
-const child_process_1$1 = require$$2;
-const promises_1$1 = promises;
-const http_1$1 = http;
-const stat = (0, promises_1$1.promisify)(fs$1.stat);
+const path$4 = require$$1;
+const fs$3 = require$$0$2;
+const child_process_1$2 = require$$2;
+const promises_1$2 = promises;
+const http_1$2 = http;
+const stat = (0, promises_1$2.promisify)(fs$3.stat);
 async function exists(filePath) {
     try {
         const existed = await stat(filePath);
@@ -16849,14 +16849,14 @@ async function exists(filePath) {
 }
 util.exists = exists;
 async function unzip(file, dest) {
-    const ex = (0, promises_1$1.promisify)(child_process_1$1.exec);
+    const ex = (0, promises_1$2.promisify)(child_process_1$2.exec);
     return ex(`unzip ${file} -d ${dest}`, { encoding: 'utf8' });
 }
 util.unzip = unzip;
-const lstat = (0, promises_1$1.promisify)(fs$1.lstat);
-const unlink = (0, promises_1$1.promisify)(fs$1.unlink);
-const readdir = (0, promises_1$1.promisify)(fs$1.readdir);
-const rmdir = (0, promises_1$1.promisify)(fs$1.rmdir);
+const lstat = (0, promises_1$2.promisify)(fs$3.lstat);
+const unlink = (0, promises_1$2.promisify)(fs$3.unlink);
+const readdir = (0, promises_1$2.promisify)(fs$3.readdir);
+const rmdir = (0, promises_1$2.promisify)(fs$3.rmdir);
 async function rmDir(dirPath, removeSelf = true) {
     let files;
     try {
@@ -16866,7 +16866,7 @@ async function rmDir(dirPath, removeSelf = true) {
         return;
     }
     if (files.length > 0) {
-        await (0, promises_1$1.promiseMap)(files, async (f) => {
+        await (0, promises_1$2.promiseMap)(files, async (f) => {
             const filePath = `${dirPath}/${f}`;
             const file = await lstat(filePath);
             if (file.isFile() || file.isSymbolicLink()) {
@@ -16888,7 +16888,7 @@ async function resolveRuntimeVersion(versionOrChannel) {
     if (isVersion) {
         const mustMatch = takeWhile(splitVersion, (x) => x !== '*');
         if (4 - mustMatch.length > 0) {
-            const res = await (0, http_1$1.fetch)('https://cdn.openfin.co/release/runtimeVersions');
+            const res = await (0, http_1$2.fetch)('https://cdn.openfin.co/release/runtimeVersions');
             const versions = res.split('\n');
             const match = first(versions, (v) => v.split('.').slice(0, mustMatch.length).join('.') === mustMatch.join('.'));
             if (match) {
@@ -16900,7 +16900,7 @@ async function resolveRuntimeVersion(versionOrChannel) {
         }
     }
     try {
-        return await (0, http_1$1.fetch)(`https://cdn.openfin.co/release/runtime/${versionOrChannel}`);
+        return await (0, http_1$2.fetch)(`https://cdn.openfin.co/release/runtime/${versionOrChannel}`);
     }
     catch (err) {
         throw Error('Could not resolve runtime version');
@@ -16919,13 +16919,13 @@ util.first = first;
 function takeWhile(arr, func) {
     return arr.reduce(({ take, vals }, x, i, r) => take && func(x, i, r) ? { take: true, vals: [...vals, x] } : { take: false, vals }, { take: true, vals: [] }).vals;
 }
-const mkdir = (0, promises_1$1.promisify)(fs$1.mkdir);
+const mkdir$1 = (0, promises_1$2.promisify)(fs$3.mkdir);
 async function resolveDir(base, paths) {
     return paths.reduce(async (p, next) => {
         try {
             const prev = await p;
-            await mkdir(path$1.resolve(prev, next));
-            return path$1.join(prev, next);
+            await mkdir$1(path$4.resolve(prev, next));
+            return path$4.join(prev, next);
         }
         catch (err) {
             return err.code === 'EEXIST' ? err.path : Promise.reject(err);
@@ -16934,157 +16934,109 @@ async function resolveDir(base, paths) {
 }
 util.resolveDir = resolveDir;
 
-var services = {};
-
-var hasRequiredServices;
-
-function requireServices () {
-	if (hasRequiredServices) return services;
-	hasRequiredServices = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.startServices = exports.launchService = exports.lookupServiceUrl = void 0;
-		const main_1 = requireMain();
-		const http_1 = http;
-		const promises_1 = promises;
-		const appDirectoryHost = process.env.appDirectoryHost || 'https://app-directory.openfin.co';
-		const lookupServiceUrl = async (serviceName) => {
-		    if (appDirectoryHost.length > 0) {
-		        const appUrl = `${appDirectoryHost}/api/v1/apps/services.${serviceName}`;
-		        const mani = await (0, http_1.fetchJson)(appUrl);
-		        return mani.manifest_url;
-		    }
-		    console.error(`error getting startup url for ${serviceName}, host: ${appDirectoryHost}`);
-		    return '';
-		};
-		exports.lookupServiceUrl = lookupServiceUrl;
-		const launchService = async (service) => {
-		    let sURL = '';
-		    if (service.manifestUrl) {
-		        sURL = service.manifestUrl;
-		    }
-		    else {
-		        sURL = await (0, exports.lookupServiceUrl)(service.name);
-		    }
-		    await (0, main_1.launch)({ manifestUrl: sURL });
-		};
-		exports.launchService = launchService;
-		const startServices = async (services) => {
-		    await (0, promises_1.promiseMapSerial)(services, exports.launchService);
-		};
-		exports.startServices = startServices; 
-	} (services));
-	return services;
+Object.defineProperty(nixLaunch, "__esModule", { value: true });
+nixLaunch.launch = nixLaunch.install = nixLaunch.getRuntimePath = nixLaunch.download = nixLaunch.getUrl = void 0;
+const fs$2 = require$$0$2;
+const path$3 = require$$1;
+const child_process_1$1 = require$$2;
+const promises_1$1 = promises;
+const util_1$1 = util;
+const http_1$1 = http;
+const mkdir = (0, promises_1$1.promisify)(fs$2.mkdir);
+const downloads = {};
+function getUrl(version, urlPath) {
+    const runtimeRoot = process.env.assetsUrl || 'https://cdn.openfin.co/release/runtime/';
+    return `${runtimeRoot}${urlPath}/${version}`;
 }
-
-var hasRequiredNixLaunch;
-
-function requireNixLaunch () {
-	if (hasRequiredNixLaunch) return nixLaunch;
-	hasRequiredNixLaunch = 1;
-	Object.defineProperty(nixLaunch, "__esModule", { value: true });
-	nixLaunch.launch = nixLaunch.install = nixLaunch.getRuntimePath = nixLaunch.download = nixLaunch.getUrl = void 0;
-	const fs = require$$0$2;
-	const path = require$$1;
-	const child_process_1 = require$$2;
-	const promises_1 = promises;
-	const util_1 = util;
-	const http_1 = http;
-	const services_1 = requireServices();
-	const mkdir = (0, promises_1.promisify)(fs.mkdir);
-	const downloads = {};
-	function getUrl(version, urlPath) {
-	    const runtimeRoot = process.env.assetsUrl || 'https://cdn.openfin.co/release/runtime/';
-	    return `${runtimeRoot}${urlPath}/${version}`;
-	}
-	nixLaunch.getUrl = getUrl;
-	async function download(version, folder, osConfig) {
-	    const url = getUrl(version, osConfig.urlPath);
-	    const tmp = 'tmp';
-	    await (0, util_1.rmDir)(folder, false);
-	    await mkdir(path.join(folder, tmp)).catch(() => {
-	        // empty block
-	    });
-	    const file = path.join(folder, tmp, 'tmp');
-	    await (0, http_1.downloadFile)(url, file);
-	    await (0, util_1.unzip)(file, folder);
-	    await (0, util_1.rmDir)(path.join(folder, tmp), true);
-	    return folder;
-	}
-	nixLaunch.download = download;
-	async function getRuntimePath(version) {
-	    if (process.env.runtimeDirectory) {
-	        return (0, util_1.resolveDir)(process.env.runtimeDirectory, ['Runtime', version]);
-	    }
-	    const versionPath = ['OpenFin', 'Runtime', version];
-	    const { HOME } = process.env;
-	    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-	    return (0, util_1.resolveDir)(HOME, versionPath);
-	}
-	nixLaunch.getRuntimePath = getRuntimePath;
-	async function install(versionOrChannel, osConfig) {
-	    const version = await (0, util_1.resolveRuntimeVersion)(versionOrChannel);
-	    const rtFolder = await getRuntimePath(version);
-	    const rtPath = path.join(rtFolder, osConfig.executablePath);
-	    const rtExists = await (0, util_1.exists)(rtPath);
-	    if (rtExists) {
-	        await (0, promises_1.promisify)(fs.chmod)(rtPath, 0o755);
-	    }
-	    else {
-	        try {
-	            if (!downloads[version]) {
-	                downloads[version] = download(version, rtFolder, osConfig);
-	            }
-	            await downloads[version];
-	            delete downloads[version];
-	        }
-	        catch (err) {
-	            console.error(`Failed to download, attempting to empty ${rtFolder}`);
-	            await (0, util_1.rmDir)(rtFolder, false);
-	            throw Error(`Could not install runtime ${versionOrChannel} (${version})`);
-	        }
-	    }
-	    return rtPath;
-	}
-	nixLaunch.install = install;
-	async function launch(config, osConfig) {
-	    try {
-	        let fb = false;
-	        const runtimePath = await install(config.runtime.version, osConfig).catch((e) => {
-	            if (config.runtime.fallbackVersion !== undefined) {
-	                fb = true;
-	                console.warn(`could not install openfin ${config.runtime.version}`);
-	                console.warn(`trying fallback ${config.runtime.fallbackVersion}`);
-	                return install(config.runtime.fallbackVersion, osConfig);
-	            }
-	            return Promise.reject(e);
-	        });
-	        const args = config.runtime.arguments ? config.runtime.arguments.split(' ') : [];
-	        if (process.env.runtimeArgs) {
-	            args.push(process.env.runtimeArgs.split(' '));
-	        }
-	        args.unshift(`--startup-url=${osConfig.manifestLocation}`);
-	        args.push(`--version-keyword=${fb ? config.runtime.fallbackVersion : config.runtime.version}`);
-	        args.push(`--runtime-information-channel-v6=${osConfig.namedPipeName}`);
-	        if (config.runtime.securityRealm) {
-	            args.push(`--security-realm=${config.runtime.securityRealm}`);
-	        }
-	        if (config.runtime.verboseLogging) {
-	            args.push('--v=1');
-	            args.push('--attach-console');
-	        }
-	        if (typeof config.services !== 'undefined' && config.services !== null) {
-	            await (0, services_1.startServices)(config.services);
-	        }
-	        return (0, child_process_1.spawn)(runtimePath, args);
-	    }
-	    catch (e) {
-	        console.error('Failed to launch\n', e);
-	        throw e;
-	    }
-	}
-	nixLaunch.launch = launch;
-	return nixLaunch;
+nixLaunch.getUrl = getUrl;
+async function download(version, folder, osConfig) {
+    const url = getUrl(version, osConfig.urlPath);
+    const tmp = 'tmp';
+    await (0, util_1$1.rmDir)(folder, false);
+    await mkdir(path$3.join(folder, tmp)).catch(() => {
+        // empty block
+    });
+    const file = path$3.join(folder, tmp, 'tmp');
+    await (0, http_1$1.downloadFile)(url, file);
+    await (0, util_1$1.unzip)(file, folder);
+    await (0, util_1$1.rmDir)(path$3.join(folder, tmp), true);
+    return folder;
+}
+nixLaunch.download = download;
+async function getRuntimePath(version) {
+    if (process.env.runtimeDirectory) {
+        return (0, util_1$1.resolveDir)(process.env.runtimeDirectory, ['Runtime', version]);
+    }
+    const versionPath = ['OpenFin', 'Runtime', version];
+    const { HOME } = process.env;
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    return (0, util_1$1.resolveDir)(HOME, versionPath);
+}
+nixLaunch.getRuntimePath = getRuntimePath;
+async function install(versionOrChannel, osConfig) {
+    const version = await (0, util_1$1.resolveRuntimeVersion)(versionOrChannel);
+    const rtFolder = await getRuntimePath(version);
+    const rtPath = path$3.join(rtFolder, osConfig.executablePath);
+    const rtExists = await (0, util_1$1.exists)(rtPath);
+    if (rtExists) {
+        await (0, promises_1$1.promisify)(fs$2.chmod)(rtPath, 0o755);
+    }
+    else {
+        try {
+            if (!downloads[version]) {
+                downloads[version] = download(version, rtFolder, osConfig);
+            }
+            await downloads[version];
+            delete downloads[version];
+        }
+        catch (err) {
+            console.error(`Failed to download, attempting to empty ${rtFolder}`);
+            await (0, util_1$1.rmDir)(rtFolder, false);
+            throw Error(`Could not install runtime ${versionOrChannel} (${version})`);
+        }
+    }
+    return rtPath;
+}
+nixLaunch.install = install;
+async function launch$1(config, osConfig) {
+    try {
+        let fb = false;
+        const runtimePath = await install(config.runtime.version, osConfig).catch((e) => {
+            if (config.runtime.fallbackVersion !== undefined) {
+                fb = true;
+                console.warn(`could not install openfin ${config.runtime.version}`);
+                console.warn(`trying fallback ${config.runtime.fallbackVersion}`);
+                return install(config.runtime.fallbackVersion, osConfig);
+            }
+            return Promise.reject(e);
+        });
+        const args = config.runtime.arguments ? config.runtime.arguments.split(' ') : [];
+        if (process.env.runtimeArgs) {
+            args.push(process.env.runtimeArgs.split(' '));
+        }
+        args.unshift(`--startup-url=${osConfig.manifestLocation}`);
+        args.push(`--version-keyword=${fb ? config.runtime.fallbackVersion : config.runtime.version}`);
+        args.push(`--runtime-information-channel-v6=${osConfig.namedPipeName}`);
+        if (config.runtime.securityRealm) {
+            args.push(`--security-realm=${config.runtime.securityRealm}`);
+        }
+        if (config.runtime.verboseLogging) {
+            args.push('--v=1');
+            args.push('--attach-console');
+        }
+        warnIfServicesProvided(config);
+        return (0, child_process_1$1.spawn)(runtimePath, args);
+    }
+    catch (e) {
+        console.error('Failed to launch\n', e);
+        throw e;
+    }
+}
+nixLaunch.launch = launch$1;
+function warnIfServicesProvided(config) {
+    if (typeof config.services !== 'undefined' && config.services !== null) {
+        console.warn('services are deprecated and will be ignored');
+    }
 }
 
 var rvmLaunch = {};
@@ -17092,16 +17044,16 @@ var rvmLaunch = {};
 Object.defineProperty(rvmLaunch, "__esModule", { value: true });
 rvmLaunch.launch = void 0;
 const child_process_1 = require$$2;
-const os = require$$1$1;
-const path = require$$1;
+const os$2 = require$$1$1;
+const path$2 = require$$1;
 const util_1 = util;
 const getRvmPath = () => {
     switch (process.platform) {
         case 'darwin':
-            return path.resolve(os.homedir(), 'Applications', 'OpenFinRVM.app', 'Contents', 'MacOS', 'OpenFinRVM');
+            return path$2.resolve(os$2.homedir(), 'Applications', 'OpenFinRVM.app', 'Contents', 'MacOS', 'OpenFinRVM');
         case 'win32':
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return path.resolve(process.env.LOCALAPPDATA, 'OpenFin', 'OpenFinRVM.exe');
+            return path$2.resolve(process.env.LOCALAPPDATA, 'OpenFin', 'OpenFinRVM.exe');
         default:
             throw new Error(`Unsupported platform: ${process.platform}`);
     }
@@ -17109,9 +17061,9 @@ const getRvmPath = () => {
 const getRvmLocalPath = () => {
     switch (process.platform) {
         case 'darwin':
-            return path.resolve(__dirname, '..', 'resources', 'darwin', 'OpenFinRVM.app', 'Contents', 'MacOS', 'OpenFinRVM');
+            return path$2.resolve(__dirname, '..', 'resources', 'darwin', 'OpenFinRVM.app', 'Contents', 'MacOS', 'OpenFinRVM');
         case 'win32':
-            return path.resolve(__dirname, '..', 'resources', 'win', 'OpenFinRVM.exe');
+            return path$2.resolve(__dirname, '..', 'resources', 'win', 'OpenFinRVM.exe');
         default:
             throw new Error(`Unsupported platform: ${process.platform}`);
     }
@@ -17160,51 +17112,44 @@ function makeQueued(func) {
     };
 }
 
-var hasRequiredLauncher;
-
-function requireLauncher () {
-	if (hasRequiredLauncher) return launcher;
-	hasRequiredLauncher = 1;
-	Object.defineProperty(launcher, "__esModule", { value: true });
-	const os = require$$1$1;
-	const path = require$$1;
-	const nix_launch_1 = requireNixLaunch();
-	const rvm_launch_1 = rvmLaunch;
-	class Launcher {
-	    constructor() {
-	        this.Installer_Work_Dir = path.join(os.tmpdir(), 'openfinnode');
-	        this.Security_Realm_Config_Key = '--security-realm=';
-	        if (!Launcher.IS_SUPPORTED()) {
-	            throw new Error(`Launching not supported on ${os.platform()}`);
-	        }
-	    }
-	    async launch(config, manifestLocation, namedPipeName) {
-	        if (Launcher.RVM_SUPPORTED()) {
-	            return (0, rvm_launch_1.launch)(config, manifestLocation, namedPipeName);
-	        }
-	        if (os.platform() === 'linux') {
-	            const osConfig = {
-	                manifestLocation,
-	                namedPipeName,
-	                urlPath: `linux/${os.arch()}`,
-	                executablePath: 'openfin'
-	            };
-	            return (0, nix_launch_1.launch)(config, osConfig);
-	        }
-	        throw new Error(`Launching not supported on ${os.platform()}`);
-	    }
-	    static IS_SUPPORTED() {
-	        const platform = os.platform();
-	        return ['win32', 'darwin', 'linux'].includes(platform);
-	    }
-	    static RVM_SUPPORTED() {
-	        const platform = os.platform();
-	        return ['win32', 'darwin'].includes(platform);
-	    }
-	}
-	launcher.default = Launcher;
-	return launcher;
+Object.defineProperty(launcher$1, "__esModule", { value: true });
+const os$1 = require$$1$1;
+const path$1 = require$$1;
+const nix_launch_1 = nixLaunch;
+const rvm_launch_1 = rvmLaunch;
+class Launcher {
+    constructor() {
+        this.Installer_Work_Dir = path$1.join(os$1.tmpdir(), 'openfinnode');
+        this.Security_Realm_Config_Key = '--security-realm=';
+        if (!Launcher.IS_SUPPORTED()) {
+            throw new Error(`Launching not supported on ${os$1.platform()}`);
+        }
+    }
+    async launch(config, manifestLocation, namedPipeName) {
+        if (Launcher.RVM_SUPPORTED()) {
+            return (0, rvm_launch_1.launch)(config, manifestLocation, namedPipeName);
+        }
+        if (os$1.platform() === 'linux') {
+            const osConfig = {
+                manifestLocation,
+                namedPipeName,
+                urlPath: `linux/${os$1.arch()}`,
+                executablePath: 'openfin'
+            };
+            return (0, nix_launch_1.launch)(config, osConfig);
+        }
+        throw new Error(`Launching not supported on ${os$1.platform()}`);
+    }
+    static IS_SUPPORTED() {
+        const platform = os$1.platform();
+        return ['win32', 'darwin', 'linux'].includes(platform);
+    }
+    static RVM_SUPPORTED() {
+        const platform = os$1.platform();
+        return ['win32', 'darwin'].includes(platform);
+    }
 }
+launcher$1.default = Launcher;
 
 var bufferReader = {};
 
@@ -17238,260 +17183,253 @@ class BufferReader {
 }
 bufferReader.BufferReader = BufferReader;
 
-var hasRequiredPortDiscovery;
-
-function requirePortDiscovery () {
-	if (hasRequiredPortDiscovery) return portDiscovery;
-	hasRequiredPortDiscovery = 1;
-	Object.defineProperty(portDiscovery, "__esModule", { value: true });
-	/* eslint-disable @typescript-eslint/naming-convention */
-	const fs = require$$0$2;
-	const net = require$$1$2;
-	const os = require$$1$1;
-	const path = require$$1;
-	const timers_1 = require$$4;
-	const launcher_1 = requireLauncher();
-	const buffer_reader_1 = bufferReader;
-	const wire_1 = wire;
-	const launcher = new launcher_1.default();
-	// value for message_type
-	var ChromiumMessageType;
-	(function (ChromiumMessageType) {
-	    ChromiumMessageType[ChromiumMessageType["RUNTIME_HELLO_MESSAGE"] = 65535] = "RUNTIME_HELLO_MESSAGE";
-	    ChromiumMessageType[ChromiumMessageType["RUNTIME_STRING_MESSAGE"] = 0] = "RUNTIME_STRING_MESSAGE";
-	})(ChromiumMessageType || (ChromiumMessageType = {}));
-	var DiscoverState;
-	(function (DiscoverState) {
-	    DiscoverState[DiscoverState["INIT"] = 0] = "INIT";
-	    DiscoverState[DiscoverState["HELLO"] = 1] = "HELLO";
-	    DiscoverState[DiscoverState["PORT_MESSAGE"] = 2] = "PORT_MESSAGE";
-	})(DiscoverState || (DiscoverState = {}));
-	function matchRuntimeInstance(config, message) {
-	    const args = config.runtime.arguments || '';
-	    const realm = config.runtime.securityRealm || (args.split('--security-realm=')[1] || '').split(' ')[0];
-	    if (config.runtime.version && realm) {
-	        return config.runtime.version === message.requestedVersion && realm === message.securityRealm;
-	    }
-	    if (config.runtime.version) {
-	        return config.runtime.version === message.requestedVersion && !message.securityRealm;
-	    }
-	    return false;
-	}
-	function generateManifest(config) {
-	    const manifest = {
-	        devtools_port: config.devToolsPort,
-	        startup_app: config.startupApp,
-	        lrsUrl: config.lrsUrl,
-	        assetsUrl: config.assetsUrl,
-	        licenseKey: config.licenseKey,
-	        appAssets: config.appAssets
-	    };
-	    if (config.runtime) {
-	        let runtimeArgs = '';
-	        manifest.runtime = { version: config.runtime.version, fallbackVersion: config.runtime.fallbackVersion };
-	        if (config.runtime.securityRealm) {
-	            runtimeArgs = runtimeArgs.concat(`${launcher.Security_Realm_Config_Key}${config.runtime.securityRealm} `);
-	        }
-	        if (config.runtime.verboseLogging === true) {
-	            runtimeArgs = runtimeArgs.concat('--v=1  --attach-console ');
-	        }
-	        if (config.runtime.arguments) {
-	            runtimeArgs = runtimeArgs.concat(`${config.runtime.arguments}`);
-	        }
-	        manifest.runtime.arguments = runtimeArgs;
-	    }
-	    if (config.customItems) {
-	        config.customItems.forEach((value) => {
-	            Object.assign(manifest, value);
-	        });
-	    }
-	    return manifest;
-	}
-	function onRuntimeHello(data, conn) {
-	    const reader = new buffer_reader_1.BufferReader(data);
-	    const header = readHeader(reader);
-	    if (header.message_type === ChromiumMessageType.RUNTIME_HELLO_MESSAGE) {
-	        conn.write(data);
-	    }
-	    else {
-	        console.error(`[port-discovery] Invalid port discovery hello message type ${header.message_type}`);
-	    }
-	}
-	function onDiscoverMessage(data) {
-	    const reader = new buffer_reader_1.BufferReader(data);
-	    const header = readHeader(reader);
-	    if (header.message_type === ChromiumMessageType.RUNTIME_STRING_MESSAGE) {
-	        const messageLength = reader.readInt32();
-	        const msg = reader.readString(messageLength);
-	        try {
-	            const env = JSON.parse(msg);
-	            if (env?.payload) {
-	                return env.payload;
-	            }
-	            console.warn(`[port-discovery] Discovery message did not have payload`, {
-	                header,
-	                msg,
-	                messageLength
-	            });
-	        }
-	        catch (e) {
-	            console.error(`[port-discovery] Error parsing discovery message: ${e.message}`, {
-	                header,
-	                msg,
-	                messageLength
-	            });
-	        }
-	    }
-	    else {
-	        console.error(`[port-discovery] Invalid port discovery message type ${header.message_type}`);
-	    }
-	    return undefined;
-	}
-	function readHeader(reader) {
-	    const header = {};
-	    header.payload_size = reader.readInt32();
-	    header.routing_id = reader.readInt32();
-	    header.message_type = reader.readInt32();
-	    header.flags = reader.readInt32();
-	    header.attachment_count = reader.readInt32();
-	    header.os = os.platform();
-	    if (header.os !== 'win32') {
-	        header.num_fds = reader.readInt16();
-	        header.pad = reader.readInt16();
-	    }
-	    return header;
-	}
-	class PortDiscovery {
-	    constructor(config, environment) {
-	        this.savedConfig = { ...config };
-	        this.environment = environment;
-	    }
-	    async retrievePort() {
-	        try {
-	            await this.createManifest();
-	            await this.createDiscoveryNamedPipe();
-	            const mPromise = this.listenDiscoveryMessage();
-	            const msg = await Promise.race([
-	                (async () => {
-	                    const openfin = await launcher.launch(this.savedConfig, this.manifestLocation, this.namedPipeName);
-	                    openfin.on('error', (err) => {
-	                        throw err;
-	                    });
-	                    if (this.savedConfig.runtime.verboseLogging && openfin.stdout && openfin.stderr) {
-	                        openfin.stdout.pipe(process.stdout);
-	                        openfin.stderr.pipe(process.stderr);
-	                    }
-	                    this.timeoutTimer = (0, timers_1.setTimeout)(() => {
-	                        //  provide a log to aid in debugging in case of a hanging promise
-	                        console.warn('Port Discovery is taking a while. Either the runtime is downloading or it failed to retrieve the port.');
-	                    }, 30 * 1000);
-	                    return mPromise;
-	                })(),
-	                mPromise
-	            ]);
-	            this.cleanup();
-	            return msg.port;
-	        }
-	        catch (reason) {
-	            this.cleanup();
-	            throw reason;
-	        }
-	    }
-	    createDiscoveryNamedPipe() {
-	        return new Promise((resolve, reject) => {
-	            let unix = false;
-	            const randomNum = this.environment.getRandomId();
-	            this.namedPipeName = `NodeAdapter.${randomNum}`;
-	            this.namedPipeServer = net.createServer();
-	            const pipePath = os.platform() === 'win32'
-	                ? path.join('\\\\.\\pipe\\', `chrome.${this.namedPipeName}`)
-	                : path.join(os.tmpdir(), `${this.namedPipeName}.sock`);
-	            if (os.platform() !== 'win32') {
-	                unix = true;
-	                this.namedPipeName = pipePath;
-	            }
-	            this.namedPipeServer.listen(pipePath, () => {
-	                if (unix) {
-	                    const address = this.namedPipeServer.address();
-	                    this.namedPipeName = address;
-	                    fs.chmodSync(pipePath, 0o777);
-	                }
-	                resolve();
-	            });
-	        });
-	    }
-	    listenDiscoveryMessage() {
-	        return new Promise((resolve, reject) => {
-	            this.namedPipeServer.on('connection', (conn) => {
-	                let discoverState = DiscoverState.INIT;
-	                conn.on('data', (data) => {
-	                    if (discoverState === DiscoverState.INIT) {
-	                        onRuntimeHello(data, conn);
-	                        discoverState = DiscoverState.HELLO;
-	                    }
-	                    else if (discoverState === DiscoverState.HELLO) {
-	                        const msg = onDiscoverMessage(data);
-	                        if (msg && matchRuntimeInstance(this.savedConfig, msg)) {
-	                            resolve(msg);
-	                        }
-	                        else {
-	                            console.warn('Received Port Discovery message from unexpected runtime');
-	                        }
-	                    }
-	                });
-	            });
-	            this.namedPipeServer.on('error', (err) => {
-	                reject(err);
-	            });
-	        });
-	    }
-	    createManifest() {
-	        return new Promise((resolve, reject) => {
-	            if ((0, wire_1.isExternalConfig)(this.savedConfig)) {
-	                this.manifestLocation = this.savedConfig.manifestUrl;
-	                resolve();
-	            }
-	            else {
-	                const manifestFileName = `NodeAdapter-${this.savedConfig.uuid.replace(/ /g, '-')}.json`;
-	                try {
-	                    fs.mkdirSync(launcher.Installer_Work_Dir);
-	                }
-	                catch (e) {
-	                    if (!e.message.includes('file already exists')) {
-	                        reject(new Error(`Error creating work directory ${e.message}`));
-	                        return;
-	                    }
-	                }
-	                this.manifestLocation = path.join(launcher.Installer_Work_Dir, manifestFileName);
-	                const wr = fs.createWriteStream(this.manifestLocation);
-	                const manifest = generateManifest(this.savedConfig);
-	                wr.on('error', (err) => {
-	                    reject(err);
-	                });
-	                wr.on('finish', () => {
-	                    resolve();
-	                });
-	                wr.write(JSON.stringify(manifest), () => {
-	                    wr.end();
-	                });
-	            }
-	        });
-	    }
-	    cleanup() {
-	        if (this.namedPipeServer) {
-	            if (this.pipeConnection) {
-	                this.pipeConnection.end();
-	            }
-	            this.namedPipeServer.close();
-	        }
-	        if (this.timeoutTimer) {
-	            clearTimeout(this.timeoutTimer);
-	        }
-	    }
-	}
-	portDiscovery.default = PortDiscovery;
-	return portDiscovery;
+Object.defineProperty(portDiscovery, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/naming-convention */
+const fs$1 = require$$0$2;
+const net = require$$1$2;
+const os = require$$1$1;
+const path = require$$1;
+const timers_1 = require$$4;
+const launcher_1 = launcher$1;
+const buffer_reader_1 = bufferReader;
+const wire_1$2 = wire;
+const launcher = new launcher_1.default();
+// value for message_type
+var ChromiumMessageType;
+(function (ChromiumMessageType) {
+    ChromiumMessageType[ChromiumMessageType["RUNTIME_HELLO_MESSAGE"] = 65535] = "RUNTIME_HELLO_MESSAGE";
+    ChromiumMessageType[ChromiumMessageType["RUNTIME_STRING_MESSAGE"] = 0] = "RUNTIME_STRING_MESSAGE";
+})(ChromiumMessageType || (ChromiumMessageType = {}));
+var DiscoverState;
+(function (DiscoverState) {
+    DiscoverState[DiscoverState["INIT"] = 0] = "INIT";
+    DiscoverState[DiscoverState["HELLO"] = 1] = "HELLO";
+    DiscoverState[DiscoverState["PORT_MESSAGE"] = 2] = "PORT_MESSAGE";
+})(DiscoverState || (DiscoverState = {}));
+function matchRuntimeInstance(config, message) {
+    const args = config.runtime.arguments || '';
+    const realm = config.runtime.securityRealm || (args.split('--security-realm=')[1] || '').split(' ')[0];
+    if (config.runtime.version && realm) {
+        return config.runtime.version === message.requestedVersion && realm === message.securityRealm;
+    }
+    if (config.runtime.version) {
+        return config.runtime.version === message.requestedVersion && !message.securityRealm;
+    }
+    return false;
+}
+function generateManifest(config) {
+    const manifest = {
+        devtools_port: config.devToolsPort,
+        startup_app: config.startupApp,
+        lrsUrl: config.lrsUrl,
+        assetsUrl: config.assetsUrl,
+        licenseKey: config.licenseKey,
+        appAssets: config.appAssets
+    };
+    if (config.runtime) {
+        let runtimeArgs = '';
+        manifest.runtime = { version: config.runtime.version, fallbackVersion: config.runtime.fallbackVersion };
+        if (config.runtime.securityRealm) {
+            runtimeArgs = runtimeArgs.concat(`${launcher.Security_Realm_Config_Key}${config.runtime.securityRealm} `);
+        }
+        if (config.runtime.verboseLogging === true) {
+            runtimeArgs = runtimeArgs.concat('--v=1  --attach-console ');
+        }
+        if (config.runtime.arguments) {
+            runtimeArgs = runtimeArgs.concat(`${config.runtime.arguments}`);
+        }
+        manifest.runtime.arguments = runtimeArgs;
+    }
+    if (config.customItems) {
+        config.customItems.forEach((value) => {
+            Object.assign(manifest, value);
+        });
+    }
+    return manifest;
 }
+function onRuntimeHello(data, conn) {
+    const reader = new buffer_reader_1.BufferReader(data);
+    const header = readHeader(reader);
+    if (header.message_type === ChromiumMessageType.RUNTIME_HELLO_MESSAGE) {
+        conn.write(data);
+    }
+    else {
+        console.error(`[port-discovery] Invalid port discovery hello message type ${header.message_type}`);
+    }
+}
+function onDiscoverMessage(data) {
+    const reader = new buffer_reader_1.BufferReader(data);
+    const header = readHeader(reader);
+    if (header.message_type === ChromiumMessageType.RUNTIME_STRING_MESSAGE) {
+        const messageLength = reader.readInt32();
+        const msg = reader.readString(messageLength);
+        try {
+            const env = JSON.parse(msg);
+            if (env?.payload) {
+                return env.payload;
+            }
+            console.warn(`[port-discovery] Discovery message did not have payload`, {
+                header,
+                msg,
+                messageLength
+            });
+        }
+        catch (e) {
+            console.error(`[port-discovery] Error parsing discovery message: ${e.message}`, {
+                header,
+                msg,
+                messageLength
+            });
+        }
+    }
+    else {
+        console.error(`[port-discovery] Invalid port discovery message type ${header.message_type}`);
+    }
+    return undefined;
+}
+function readHeader(reader) {
+    const header = {};
+    header.payload_size = reader.readInt32();
+    header.routing_id = reader.readInt32();
+    header.message_type = reader.readInt32();
+    header.flags = reader.readInt32();
+    header.attachment_count = reader.readInt32();
+    header.os = os.platform();
+    if (header.os !== 'win32') {
+        header.num_fds = reader.readInt16();
+        header.pad = reader.readInt16();
+    }
+    return header;
+}
+class PortDiscovery {
+    constructor(config, environment) {
+        this.savedConfig = { ...config };
+        this.environment = environment;
+    }
+    async retrievePort() {
+        try {
+            await this.createManifest();
+            await this.createDiscoveryNamedPipe();
+            const mPromise = this.listenDiscoveryMessage();
+            const msg = await Promise.race([
+                (async () => {
+                    const openfin = await launcher.launch(this.savedConfig, this.manifestLocation, this.namedPipeName);
+                    openfin.on('error', (err) => {
+                        throw err;
+                    });
+                    if (this.savedConfig.runtime.verboseLogging && openfin.stdout && openfin.stderr) {
+                        openfin.stdout.pipe(process.stdout);
+                        openfin.stderr.pipe(process.stderr);
+                    }
+                    this.timeoutTimer = (0, timers_1.setTimeout)(() => {
+                        //  provide a log to aid in debugging in case of a hanging promise
+                        console.warn('Port Discovery is taking a while. Either the runtime is downloading or it failed to retrieve the port.');
+                    }, 30 * 1000);
+                    return mPromise;
+                })(),
+                mPromise
+            ]);
+            this.cleanup();
+            return msg.port;
+        }
+        catch (reason) {
+            this.cleanup();
+            throw reason;
+        }
+    }
+    createDiscoveryNamedPipe() {
+        return new Promise((resolve, reject) => {
+            let unix = false;
+            const randomNum = this.environment.getRandomId();
+            this.namedPipeName = `NodeAdapter.${randomNum}`;
+            this.namedPipeServer = net.createServer();
+            const pipePath = os.platform() === 'win32'
+                ? path.join('\\\\.\\pipe\\', `chrome.${this.namedPipeName}`)
+                : path.join(os.tmpdir(), `${this.namedPipeName}.sock`);
+            if (os.platform() !== 'win32') {
+                unix = true;
+                this.namedPipeName = pipePath;
+            }
+            this.namedPipeServer.listen(pipePath, () => {
+                if (unix) {
+                    const address = this.namedPipeServer.address();
+                    this.namedPipeName = address;
+                    fs$1.chmodSync(pipePath, 0o777);
+                }
+                resolve();
+            });
+        });
+    }
+    listenDiscoveryMessage() {
+        return new Promise((resolve, reject) => {
+            this.namedPipeServer.on('connection', (conn) => {
+                let discoverState = DiscoverState.INIT;
+                conn.on('data', (data) => {
+                    if (discoverState === DiscoverState.INIT) {
+                        onRuntimeHello(data, conn);
+                        discoverState = DiscoverState.HELLO;
+                    }
+                    else if (discoverState === DiscoverState.HELLO) {
+                        const msg = onDiscoverMessage(data);
+                        if (msg && matchRuntimeInstance(this.savedConfig, msg)) {
+                            resolve(msg);
+                        }
+                        else {
+                            console.warn('Received Port Discovery message from unexpected runtime');
+                        }
+                    }
+                });
+            });
+            this.namedPipeServer.on('error', (err) => {
+                reject(err);
+            });
+        });
+    }
+    createManifest() {
+        return new Promise((resolve, reject) => {
+            if ((0, wire_1$2.isExternalConfig)(this.savedConfig)) {
+                this.manifestLocation = this.savedConfig.manifestUrl;
+                resolve();
+            }
+            else {
+                const manifestFileName = `NodeAdapter-${this.savedConfig.uuid.replace(/ /g, '-')}.json`;
+                try {
+                    fs$1.mkdirSync(launcher.Installer_Work_Dir);
+                }
+                catch (e) {
+                    if (!e.message.includes('file already exists')) {
+                        reject(new Error(`Error creating work directory ${e.message}`));
+                        return;
+                    }
+                }
+                this.manifestLocation = path.join(launcher.Installer_Work_Dir, manifestFileName);
+                const wr = fs$1.createWriteStream(this.manifestLocation);
+                const manifest = generateManifest(this.savedConfig);
+                wr.on('error', (err) => {
+                    reject(err);
+                });
+                wr.on('finish', () => {
+                    resolve();
+                });
+                wr.write(JSON.stringify(manifest), () => {
+                    wr.end();
+                });
+            }
+        });
+    }
+    cleanup() {
+        if (this.namedPipeServer) {
+            if (this.pipeConnection) {
+                this.pipeConnection.end();
+            }
+            this.namedPipeServer.close();
+        }
+        if (this.timeoutTimer) {
+            clearTimeout(this.timeoutTimer);
+        }
+    }
+}
+portDiscovery.default = PortDiscovery;
 
 var baseEnv = {};
 
@@ -17517,107 +17455,100 @@ class BaseEnvironment {
 }
 baseEnv.BaseEnvironment = BaseEnvironment;
 
-var hasRequiredNodeEnv;
-
-function requireNodeEnv () {
-	if (hasRequiredNodeEnv) return nodeEnv;
-	hasRequiredNodeEnv = 1;
-	Object.defineProperty(nodeEnv, "__esModule", { value: true });
-	/* eslint-disable class-methods-use-this */
-	const fs_1 = require$$0$2;
-	const crypto_1 = require$$1$3;
-	const _WS = require$$2$1;
-	const environment_1 = environment;
-	const port_discovery_1 = requirePortDiscovery();
-	const transport_errors_1 = transportErrors;
-	const base_env_1 = baseEnv;
-	// 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 extends base_env_1.BaseEnvironment {
-	    constructor() {
-	        super(...arguments);
-	        this.type = 'node';
-	        this.messageCounter = 0;
-	        this.childViews = false;
-	        this.writeToken = (path, token) => {
-	            return new Promise((resolve) => {
-	                (0, fs_1.writeFile)(path, token, () => resolve(token));
-	            });
-	        };
-	        this.retrievePort = (config) => {
-	            const pd = new port_discovery_1.default(config, this);
-	            return pd.retrievePort();
-	        };
-	        this.getNextMessageId = () => {
-	            // eslint-disable-next-line no-plusplus
-	            return this.messageCounter++;
-	        };
-	        this.getRandomId = () => {
-	            return (0, crypto_1.randomBytes)(16).toString('hex');
-	        };
-	        this.getWebWindow = (identity) => {
-	            throw new transport_errors_1.NotSupportedError('Not supported outside of OpenFin web context');
-	        };
-	        this.getCurrentEntityIdentity = () => {
-	            throw new transport_errors_1.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
-	        };
-	        this.getCurrentEntityType = () => {
-	            return 'external connection';
-	        };
-	        this.raiseEvent = (eventName, eventArgs) => {
-	            throw new transport_errors_1.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
-	        };
-	        this.getUrl = () => {
-	            throw new transport_errors_1.NotImplementedError('Not Implemented');
-	        };
-	    }
-	    observeBounds(element, onChange) {
-	        throw new Error('Method not implemented.');
-	    }
-	    getDefaultChannelOptions() {
-	        return { create: {}, connect: {} };
-	    }
-	    getRtcPeer() {
-	        throw new Error('Method not implemented.');
-	    }
-	    layoutAllowedInContext(_fin) {
-	        throw new Error('Method not implemented.');
-	    }
-	    async initLayoutManager() {
-	        throw new Error('Method not implemented.');
-	    }
-	    async applyLayoutSnapshot() {
-	        throw new Error('Method not implemented.');
-	    }
-	    async createLayout() {
-	        throw new Error('Method not implemented.');
-	    }
-	    async destroyLayout() {
-	        throw new Error('Method not implemented.');
-	    }
-	    async resolveLayout() {
-	        throw new Error('Method not implemented.');
-	    }
-	    async initPlatform() {
-	        throw new Error('Method not implemented.');
-	    }
-	    whenReady() {
-	        return Promise.resolve();
-	    }
-	    createChildContent(options) {
-	        throw new transport_errors_1.NotImplementedError('Not Implemented');
-	    }
-	    getWsConstructor() {
-	        // @ts-expect-error
-	        return WS;
-	    }
-	}
-	nodeEnv.default = NodeEnvironment;
-	return nodeEnv;
+Object.defineProperty(nodeEnv, "__esModule", { value: true });
+/* eslint-disable class-methods-use-this */
+const fs_1 = require$$0$2;
+const crypto_1 = require$$1$3;
+const _WS = require$$2$1;
+const environment_1 = environment;
+const port_discovery_1 = portDiscovery;
+const transport_errors_1$2 = transportErrors;
+const base_env_1 = baseEnv;
+// 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 extends base_env_1.BaseEnvironment {
+    constructor() {
+        super(...arguments);
+        this.type = 'node';
+        this.messageCounter = 0;
+        this.childViews = false;
+        this.writeToken = (path, token) => {
+            return new Promise((resolve) => {
+                (0, fs_1.writeFile)(path, token, () => resolve(token));
+            });
+        };
+        this.retrievePort = (config) => {
+            const pd = new port_discovery_1.default(config, this);
+            return pd.retrievePort();
+        };
+        this.getNextMessageId = () => {
+            // eslint-disable-next-line no-plusplus
+            return this.messageCounter++;
+        };
+        this.getRandomId = () => {
+            return (0, crypto_1.randomBytes)(16).toString('hex');
+        };
+        this.getWebWindow = (identity) => {
+            throw new transport_errors_1$2.NotSupportedError('Not supported outside of OpenFin web context');
+        };
+        this.getCurrentEntityIdentity = () => {
+            throw new transport_errors_1$2.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
+        };
+        this.getCurrentEntityType = () => {
+            return 'external connection';
+        };
+        this.raiseEvent = (eventName, eventArgs) => {
+            throw new transport_errors_1$2.NotImplementedError(environment_1.notImplementedEnvErrorMsg);
+        };
+        this.getUrl = () => {
+            throw new transport_errors_1$2.NotImplementedError('Not Implemented');
+        };
+    }
+    observeBounds(element, onChange) {
+        throw new Error('Method not implemented.');
+    }
+    getDefaultChannelOptions() {
+        return { create: {}, connect: {} };
+    }
+    getRtcPeer() {
+        throw new Error('Method not implemented.');
+    }
+    layoutAllowedInContext(_fin) {
+        throw new Error('Method not implemented.');
+    }
+    async initLayoutManager() {
+        throw new Error('Method not implemented.');
+    }
+    async applyLayoutSnapshot() {
+        throw new Error('Method not implemented.');
+    }
+    async createLayout() {
+        throw new Error('Method not implemented.');
+    }
+    async destroyLayout() {
+        throw new Error('Method not implemented.');
+    }
+    async resolveLayout() {
+        throw new Error('Method not implemented.');
+    }
+    async initPlatform() {
+        throw new Error('Method not implemented.');
+    }
+    whenReady() {
+        return Promise.resolve();
+    }
+    createChildContent(options) {
+        throw new transport_errors_1$2.NotImplementedError('Not Implemented');
+    }
+    getWsConstructor() {
+        // @ts-expect-error
+        return WS;
+    }
 }
+nodeEnv.default = NodeEnvironment;
 
 var transport = {};
 
@@ -18034,9 +17965,6 @@ async function normalizeConfig(config) {
         if (typeof loadedConfig.assetsUrl === 'string') {
             testThisConfig.assetsUrl = loadedConfig.assetsUrl;
         }
-        if (Array.isArray(loadedConfig.services)) {
-            testThisConfig.services = loadedConfig.services;
-        }
     }
     return testThisConfig;
 }
@@ -18050,62 +17978,53 @@ async function validateConfig(config) {
 }
 normalizeConfig$1.validateConfig = validateConfig;
 
-var hasRequiredMain;
-
-function requireMain () {
-	if (hasRequiredMain) return main$1;
-	hasRequiredMain = 1;
-	(function (exports) {
-		Object.defineProperty(exports, "__esModule", { value: true });
-		exports.ChannelProvider = exports.ChannelClient = exports.Frame = exports.View = exports.System = exports.Window = exports.Application = exports.Fin = exports.launch = exports.connect = void 0;
-		const fin_1 = fin$1;
-		Object.defineProperty(exports, "Fin", { enumerable: true, get: function () { return fin_1.Fin; } });
-		const index_1 = requireApplication();
-		Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return index_1.Application; } });
-		const window_1 = requireWindow();
-		Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return window_1._Window; } });
-		const view_1 = requireView();
-		Object.defineProperty(exports, "View", { enumerable: true, get: function () { return view_1.View; } });
-		const client_1 = client;
-		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;
-		Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return frame_1._Frame; } });
-		const system_1 = system$1;
-		Object.defineProperty(exports, "System", { enumerable: true, get: function () { return system_1.System; } });
-		const wire_1 = wire;
-		const node_env_1 = requireNodeEnv();
-		const transport_1 = transport;
-		const websocket_1 = websocket;
-		const port_discovery_1 = requirePortDiscovery();
-		const normalize_config_1 = normalizeConfig$1;
-		const environment = new node_env_1.default();
-		// Connect to an OpenFin Runtime
-		async function connect(config) {
-		    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
-		    });
-		    await wire.connect(normalized);
-		    return new fin_1.Fin(wire);
-		}
-		exports.connect = connect;
-		async function launch(config) {
-		    const normalized = await (0, normalize_config_1.normalizeConfig)(config);
-		    if (!(0, wire_1.isPortDiscoveryConfig)(normalized)) {
-		        throw new Error('Invalid Config');
-		    }
-		    const pd = new port_discovery_1.default(normalized, environment);
-		    return pd.retrievePort();
-		}
-		exports.launch = launch; 
-	} (main$1));
-	return main$1;
-}
-
-var mainExports = requireMain();
+(function (exports) {
+	Object.defineProperty(exports, "__esModule", { value: true });
+	exports.ChannelProvider = exports.ChannelClient = exports.Frame = exports.View = exports.System = exports.Window = exports.Application = exports.Fin = exports.launch = exports.connect = void 0;
+	const fin_1 = fin$1;
+	Object.defineProperty(exports, "Fin", { enumerable: true, get: function () { return fin_1.Fin; } });
+	const index_1 = requireApplication();
+	Object.defineProperty(exports, "Application", { enumerable: true, get: function () { return index_1.Application; } });
+	const window_1 = requireWindow();
+	Object.defineProperty(exports, "Window", { enumerable: true, get: function () { return window_1._Window; } });
+	const view_1 = requireView();
+	Object.defineProperty(exports, "View", { enumerable: true, get: function () { return view_1.View; } });
+	const client_1 = client;
+	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;
+	Object.defineProperty(exports, "Frame", { enumerable: true, get: function () { return frame_1._Frame; } });
+	const system_1 = system$1;
+	Object.defineProperty(exports, "System", { enumerable: true, get: function () { return system_1.System; } });
+	const wire_1 = wire;
+	const node_env_1 = nodeEnv;
+	const transport_1 = transport;
+	const websocket_1 = websocket;
+	const port_discovery_1 = portDiscovery;
+	const normalize_config_1 = normalizeConfig$1;
+	const environment = new node_env_1.default();
+	// Connect to an OpenFin Runtime
+	async function connect(config) {
+	    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
+	    });
+	    await wire.connect(normalized);
+	    return new fin_1.Fin(wire);
+	}
+	exports.connect = connect;
+	async function launch(config) {
+	    const normalized = await (0, normalize_config_1.normalizeConfig)(config);
+	    if (!(0, wire_1.isPortDiscoveryConfig)(normalized)) {
+	        throw new Error('Invalid Config');
+	    }
+	    const pd = new port_discovery_1.default(normalized, environment);
+	    return pd.retrievePort();
+	}
+	exports.launch = launch; 
+} (main$1));
 
 var OpenFin$2 = {};
 
@@ -18369,6 +18288,6 @@ var OpenFin$1 = /*#__PURE__*/_mergeNamespaces({
 	default: OpenFin
 }, [OpenFin$2]);
 
-exports.connect = mainExports.connect;
+exports.connect = main$1.connect;
 exports.default = OpenFin$1;
-exports.launch = mainExports.launch;
+exports.launch = main$1.launch;