nesoi 3.1.8 → 3.2.1

package/lib/compiler/apps/distributed/distributed_compiler.d.ts

@@ -0,0 +1,31 @@
+import { Compiler } from "../../compiler";
+import { AnyApp } from "../../../engine/apps/app";
+import { DistributedApp } from "../../../engine/apps/distributed/distributed.app";
+export type DistributedCompilerConfig = {
+    libPaths?: string[];
+    staticPaths?: string[];
+    scripts?: Record<string, string>;
+    nesoiPath?: string;
+};
+export declare class DistributedCompiler {
+    compiler: Compiler;
+    appPath: string;
+    config: DistributedCompilerConfig;
+    dirs: {
+        build: string;
+        nodes: {
+            [name: string]: {
+                build: string;
+                build_modules: string;
+                build_externals: string;
+                build_types: string;
+                build_bin: string;
+            };
+        };
+    };
+    constructor(compiler: Compiler, appPath: string, config?: DistributedCompilerConfig);
+    run(): Promise<void>;
+    mergeServicePaths(app: AnyApp): void;
+    expandLibPaths(): void;
+    static scanAll(dir: string): Promise<DistributedApp<any, any, {}>[] | undefined>;
+}

package/lib/compiler/apps/distributed/distributed_compiler.js

@@ -0,0 +1,121 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DistributedCompiler = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../engine/space");
+const console_1 = __importDefault(require("../../../engine/util/console"));
+const _1_mkdir_stage_1 = require("./stages/1_mkdir_stage");
+const _2_build_typescript_stage_1 = require("./stages/2_build_typescript_stage");
+const _3_copy_types_stage_1 = require("./stages/3_copy_types_stage");
+const _4_dump_modules_stage_1 = require("./stages/4_dump_modules_stage");
+// import { CopyStaticStage } from './stages/5_copy_static_stage';
+// import { DumpCLIStage } from './stages/6_dump_cli_stage';
+// import { DumpPackageJsonStage } from './stages/7_dump_package_json_stage';
+const log_1 = require("../../../engine/util/log");
+const app_1 = require("../../../engine/apps/app");
+const distributed_app_1 = require("../../../engine/apps/distributed/distributed.app");
+const path_1 = require("../../../engine/util/path");
+class DistributedCompiler {
+    constructor(compiler, appPath, config = {}) {
+        this.compiler = compiler;
+        this.appPath = appPath;
+        this.config = config;
+        this.dirs = {};
+    }
+    async run() {
+        console_1.default.header('Distributed Compiler');
+        log_1.Log.info('compiler', 'distributed', `Importing the Distributed definition from ${this.appPath}`);
+        const appFile = space_1.Space.path(this.compiler.space, this.appPath);
+        const app = (await Promise.resolve(`${appFile}`).then(s => __importStar(require(s)))).default;
+        this.config = Object.assign({}, app_1.App.getInfo(app).config?.compiler || {}, this.config);
+        this.mergeServicePaths(app);
+        this.expandLibPaths();
+        try {
+            await new _1_mkdir_stage_1.MkdirStage(this, app).run();
+            await new _2_build_typescript_stage_1.BuildTypescriptStage(this, app).run();
+            await new _3_copy_types_stage_1.CopyTypesStage(this, app).run();
+            await new _4_dump_modules_stage_1.DumpModulesStage(this, app).run();
+            // await new CopyStaticStage(this, app).run();
+            // await new DumpCLIStage(this, app).run();   
+            // await new DumpPackageJsonStage(this, app).run();
+        }
+        catch (e) {
+            log_1.Log.error('compiler', 'distributed', e.toString(), { stack: e.stack });
+            process.exit(1);
+        }
+    }
+    mergeServicePaths(app) {
+        var _a;
+        const services = app_1.App.getServices(app);
+        for (const name in services) {
+            const service = services[name];
+            if (!service.libPaths)
+                continue;
+            (_a = this.config).libPaths ?? (_a.libPaths = []);
+            this.config.libPaths.push(...service.libPaths);
+        }
+    }
+    expandLibPaths() {
+        var _a;
+        const expandedPaths = [];
+        (_a = this.config).libPaths ?? (_a.libPaths = []);
+        for (const path of this.config.libPaths) {
+            const expanded = path_1.Path.expandWildcard(path);
+            expandedPaths.push(...expanded);
+        }
+        this.config.libPaths = expandedPaths;
+    }
+    static async scanAll(dir) {
+        const apps = [];
+        const nodes = fs.readdirSync(dir, { withFileTypes: true });
+        for (const node of nodes) {
+            const nodePath = path.resolve(dir, node.name);
+            if (!nodePath.endsWith('.ts')) {
+                return;
+            }
+            const exported = (await Promise.resolve(`${nodePath}`).then(s => __importStar(require(s))))?.default;
+            if (exported instanceof distributed_app_1.DistributedApp) {
+                apps.push(exported);
+            }
+        }
+        return apps;
+    }
+}
+exports.DistributedCompiler = DistributedCompiler;

package/lib/compiler/apps/distributed/stages/1_mkdir_stage.d.ts

@@ -0,0 +1,15 @@
+import { DistributedApp } from "../../../../engine/apps/distributed/distributed.app";
+import { DistributedCompiler } from '../distributed_compiler';
+/**
+ * [Distributed Compiler Stage #1]
+ * Create the directory structure
+ *
+ * @category Distributed Compiler
+ * @subcategory Stages
+ */
+export declare class MkdirStage {
+    private distributed;
+    private app;
+    constructor(distributed: DistributedCompiler, app: DistributedApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/distributed/stages/1_mkdir_stage.js

@@ -0,0 +1,96 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MkdirStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+/**
+ * [Distributed Compiler Stage #1]
+ * Create the directory structure
+ *
+ * @category Distributed Compiler
+ * @subcategory Stages
+ */
+class MkdirStage {
+    constructor(distributed, app) {
+        this.distributed = distributed;
+        this.app = app;
+    }
+    async run() {
+        log_1.Log.info('compiler', 'distributed', 'Creating build directory tree');
+        const dirs = this.distributed.dirs;
+        dirs.build = space_1.Space.path(this.distributed.compiler.space, 'build', this.app.name);
+        // Remove build folder
+        log_1.Log.debug('compiler', 'distributed', `Removing folder ${dirs.build}`);
+        fs.rmSync(dirs.build, { recursive: true, force: true });
+        // Create build folder
+        log_1.Log.debug('compiler', 'distributed', `Creating folder ${dirs.build}`);
+        fs.mkdirSync(dirs.build, { recursive: true });
+        dirs.nodes = {};
+        for (const name in this.app.nodes) {
+            dirs.nodes[name] = {
+                build: path.resolve(dirs.build, name),
+                build_modules: path.resolve(dirs.build, name, 'modules'),
+                build_externals: path.resolve(dirs.build, name, 'externals'),
+                build_types: path.resolve(dirs.build, name, 'types'),
+                build_bin: path.resolve(dirs.build, name, 'bin'),
+            };
+            const nodeDirs = dirs.nodes[name];
+            // Create build/<node>/modules folder
+            log_1.Log.debug('compiler', 'distributed', `Creating folder ${nodeDirs.build_modules}`);
+            if (!fs.existsSync(nodeDirs.build_modules)) {
+                fs.mkdirSync(nodeDirs.build_modules, { recursive: true });
+            }
+            // Create build/<node>/externals folder
+            log_1.Log.debug('compiler', 'distributed', `Creating folder ${nodeDirs.build_externals}`);
+            if (!fs.existsSync(nodeDirs.build_externals)) {
+                fs.mkdirSync(nodeDirs.build_externals, { recursive: true });
+            }
+            // Create build/<node>/types folder
+            log_1.Log.debug('compiler', 'distributed', `Creating folder ${nodeDirs.build_types}`);
+            if (!fs.existsSync(nodeDirs.build_types)) {
+                fs.mkdirSync(nodeDirs.build_types, { recursive: true });
+            }
+            // Create build/<node>/bin folder
+            log_1.Log.debug('compiler', 'distributed', `Creating folder ${nodeDirs.build_bin}`);
+            if (!fs.existsSync(nodeDirs.build_bin)) {
+                fs.mkdirSync(nodeDirs.build_bin, { recursive: true });
+            }
+        }
+    }
+}
+exports.MkdirStage = MkdirStage;

package/lib/compiler/apps/distributed/stages/2_build_typescript_stage.d.ts

@@ -0,0 +1,15 @@
+import { DistributedApp } from "../../../../engine/apps/distributed/distributed.app";
+import { DistributedCompiler } from '../distributed_compiler';
+/**
+ * [Distributed Compiler Stage #2]
+ * Build typescript files to build folder
+ *
+ * @category Distributed Compiler
+ * @subcategory Stages
+ */
+export declare class BuildTypescriptStage {
+    private distributed;
+    private app;
+    constructor(distributed: DistributedCompiler, app: DistributedApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/distributed/stages/2_build_typescript_stage.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildTypescriptStage = void 0;
+const ts = __importStar(require("typescript"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+const typescript_compiler_1 = require("../../../typescript/typescript_compiler");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [Distributed Compiler Stage #2]
+ * Build typescript files to build folder
+ *
+ * @category Distributed Compiler
+ * @subcategory Stages
+ */
+class BuildTypescriptStage {
+    constructor(distributed, app) {
+        this.distributed = distributed;
+        this.app = app;
+    }
+    async run() {
+        const { config, compiler, dirs: _dirs, appPath } = this.distributed;
+        for (const name in this.app.nodes) {
+            log_1.Log.info('compiler', 'distributed', `[${name}] Building TypeScript files...`);
+            const node = this.app.nodes[name];
+            const dirs = _dirs.nodes[name];
+            const libPaths = (config.libPaths || []).map(path => {
+                return space_1.Space.path(compiler.space, path);
+            });
+            const binFiles = Object.values(config.scripts || {}).map(path => {
+                return space_1.Space.path(compiler.space, path);
+            });
+            const info = app_1.App.getInfo(node);
+            const modulePaths = [];
+            space_1.Space.scan(compiler.space, (name) => {
+                if (info.spaceModules.includes(name)) {
+                    modulePaths.push(space_1.Space.path(compiler.space, '.nesoi', name));
+                }
+            });
+            const space = compiler.space;
+            const spacePath = space_1.Space.path(space);
+            const libFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(libPaths);
+            const appFile = space_1.Space.path(space, appPath);
+            const nesoiFile = space_1.Space.path(space, 'nesoi.ts');
+            const moduleFiles = typescript_compiler_1.TypeScriptCompiler.allFiles(modulePaths);
+            const replacePaths = {
+                [nesoiFile]: { __remove: true },
+                '$': { __remove: true },
+                [appFile]: path.resolve(dirs.build, 'app.js'),
+                '.nesoi': path.resolve(dirs.build, 'types'),
+            };
+            const tsPaths = {
+                '$': [nesoiFile]
+            };
+            if (config.nesoiPath) {
+                tsPaths['nesoi/*'] = [`${config.nesoiPath}/*`];
+            }
+            const moduleDirs = Object.values(compiler.modules).map(mod => [mod.module.name, space_1.Space.path(compiler.space, 'modules', ...mod.module.subdir, mod.module.name)]);
+            libFiles.forEach(lib => {
+                let libModule;
+                for (const [module, modulePath] of moduleDirs) {
+                    if (lib.startsWith(modulePath)) {
+                        libModule = { name: module, path: modulePath };
+                        break;
+                    }
+                }
+                let outPath;
+                if (!libModule) {
+                    lib = space_1.Space.relPath(compiler.space, lib);
+                    outPath = path.resolve(dirs.build, lib);
+                }
+                else {
+                    const rel = path.relative(libModule.path, lib);
+                    outPath = path.resolve(dirs.build, 'modules', libModule.name, rel);
+                }
+                replacePaths[lib] = path.resolve(dirs.build, outPath);
+            });
+            libPaths.forEach(lib => {
+                let libModule;
+                for (const [module, modulePath] of moduleDirs) {
+                    if (lib.startsWith(modulePath)) {
+                        libModule = { name: module, path: modulePath };
+                        break;
+                    }
+                }
+                let outPath;
+                if (!libModule) {
+                    lib = space_1.Space.relPath(compiler.space, lib);
+                    outPath = path.resolve(dirs.build, lib);
+                }
+                else {
+                    const rel = path.relative(libModule.path, lib);
+                    outPath = path.resolve(dirs.build, 'modules', libModule.name, rel);
+                }
+                replacePaths[lib] = path.resolve(dirs.build, outPath);
+                tsPaths[lib + '/*'] = [space_1.Space.path(compiler.space, lib) + '/*'];
+            });
+            tsPaths['.nesoi/*'] = [space_1.Space.path(compiler.space, '.nesoi') + '/*'];
+            const dotNesoiPath = space_1.Space.path(compiler.space, '.nesoi');
+            moduleFiles.forEach(moduleFile => {
+                const module = moduleFile.replace(dotNesoiPath, '').split(path.sep)[1];
+                if (!module?.length) {
+                    throw new Error(`Unable to find module name from path ${moduleFile}`);
+                }
+                const filename = path.basename(moduleFile).replace(/\.ts$/, '.js');
+                replacePaths[moduleFile] = path.resolve(dirs.build, 'modules', module, filename);
+            });
+            binFiles.forEach(binFile => {
+                const filename = path.basename(binFile).replace(/\.ts$/, '.js');
+                replacePaths[binFile] = path.resolve(dirs.build, 'bin', filename);
+            });
+            const emitCode = typescript_compiler_1.TypeScriptCompiler.compileApp(info.spaceModules, [
+                appFile,
+                ...libFiles,
+                ...binFiles,
+                ...moduleFiles
+            ], {
+                target: ts.ScriptTarget.ES2020,
+                module: ts.ModuleKind.CommonJS,
+                moduleResolution: ts.ModuleResolutionKind.Node10,
+                noEmitOnError: true,
+                declaration: true,
+                strict: true,
+                esModuleInterop: true,
+                paths: {
+                    ...tsPaths
+                },
+                rootDir: space_1.Space.path(space),
+                outDir: dirs.build,
+                // Built methods don't carry all the typings, so we disable this check
+                // However, this has been checked before Compiler built them
+                noImplicitAny: false,
+            }, spacePath, dirs.build, replacePaths);
+            if (emitCode !== 0) {
+                throw new Error('One or more TypeScript files contains errors.');
+            }
+        }
+    }
+}
+exports.BuildTypescriptStage = BuildTypescriptStage;

package/lib/compiler/apps/distributed/stages/3_copy_types_stage.d.ts

@@ -0,0 +1,15 @@
+import { DistributedApp } from "../../../../engine/apps/distributed/distributed.app";
+import { DistributedCompiler } from '../distributed_compiler';
+/**
+ * [distributed Compiler Stage #3]
+ * Copy type declarations to build/types folder
+ *
+ * @category distributed Compiler
+ * @subcategory Stages
+ */
+export declare class CopyTypesStage {
+    private distributed;
+    private app;
+    constructor(distributed: DistributedCompiler, app: DistributedApp<any, any>);
+    run(): Promise<void>;
+}

package/lib/compiler/apps/distributed/stages/3_copy_types_stage.js

@@ -0,0 +1,82 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CopyTypesStage = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const space_1 = require("../../../../engine/space");
+const log_1 = require("../../../../engine/util/log");
+const name_helpers_1 = require("../../../helpers/name_helpers");
+const app_1 = require("../../../../engine/apps/app");
+/**
+ * [distributed Compiler Stage #3]
+ * Copy type declarations to build/types folder
+ *
+ * @category distributed Compiler
+ * @subcategory Stages
+ */
+class CopyTypesStage {
+    constructor(distributed, app) {
+        this.distributed = distributed;
+        this.app = app;
+    }
+    async run() {
+        const { compiler, dirs: _dirs } = this.distributed;
+        for (const name in this.app.nodes) {
+            log_1.Log.info('compiler', 'distributed', `[${name}] Copying module and space types from .nesoi to build/types folder...`);
+            const node = this.app.nodes[name];
+            const dirs = _dirs.nodes[name];
+            const info = app_1.App.getInfo(node);
+            // Copy module types to types folder
+            for (const name of info.spaceModules) {
+                const module = compiler.modules[name];
+                const from = space_1.Space.path(compiler.space, '.nesoi', module.lowName + '.module.ts');
+                const to = path.resolve(dirs.build_types, module.lowName + '.module.ts');
+                log_1.Log.debug('compiler', 'distributed', `Copying module types from ${from} to ${to}`);
+                fs.cpSync(from, to, { recursive: true });
+            }
+            // Copy space type to types folder
+            {
+                const space = compiler.space._name;
+                const spaceLow = name_helpers_1.NameHelpers.nameHighToLow(space);
+                const from = space_1.Space.path(compiler.space, '.nesoi', spaceLow + '.ts');
+                const to = path.resolve(dirs.build_types, spaceLow + '.ts');
+                log_1.Log.debug('compiler', 'distributed', `Copying space types from ${from} to ${to}`);
+                fs.cpSync(from, to, { recursive: true });
+            }
+        }
+    }
+}
+exports.CopyTypesStage = CopyTypesStage;

package/lib/compiler/apps/distributed/stages/4_dump_modules_stage.d.ts

@@ -0,0 +1,16 @@
+import { DistributedApp } from "../../../../engine/apps/distributed/distributed.app";
+import { DistributedCompiler } from '../distributed_compiler';
+/**
+ * [distributed Compiler Stage #4]
+ * Dump modules to build/modules folder.
+ *
+ * @category distributed Compiler
+ * @subcategory Stages
+ */
+export declare class DumpModulesStage {
+    private distributed;
+    private app;
+    constructor(distributed: DistributedCompiler, app: DistributedApp<any, any>);
+    run(): Promise<void>;
+    private dumpModule;
+}