@lensmcp/cluster 1.0.0

package/executors/serve/schema.d.ts

@@ -0,0 +1,53 @@
+export interface WorkerEntryPoint {
+  name: string;
+  entryPath: string;
+}
+
+export interface NodeExternalsConfig {
+  allowlist?: string[];
+  additionalModuleDirs?: string[];
+  importType?: string;
+}
+
+export interface GatewayRoute {
+  /** Hostname to match - exact or `*.suffix` wildcard. */
+  host?: string;
+  /** URL prefix to match (e.g. `/api`). */
+  prefix?: string;
+  /** Proxy destination URL; omit -> this service children. */
+  target?: string;
+  /** Prepend to the forwarded URL (e.g. `/api`) - serve a prefixed app at its dev domain ROOT. */
+  prependPrefix?: string;
+}
+
+export interface GatewayConfig {
+  /** Path to a JS request-middleware module (headers injection etc.). */
+  middleware?: string;
+  /** Front-gateway routes (hostname + prefix -> target or own children). */
+  routes?: GatewayRoute[];
+  /** Terminate TLS with a cached self-signed cert (basic-ssl style). */
+  https?: boolean;
+  /** Additional listener ports with the same routing (e.g. [443] for port-less dev domains). */
+  extraPorts?: number[];
+}
+
+export interface ServeExecutorSchema {
+  entryFile: string;
+  tsConfigFile: string;
+  outputPath?: string;
+  assets?: string[];
+  workers?: WorkerEntryPoint[];
+  configEnv?: string;
+  memoryLimit?: number;
+  childCount?: number;
+  buildLibsFromSource?: boolean;
+  orgScopes?: string[];
+  bundlePackages?: string[];
+  nodeExternalsConfig?: NodeExternalsConfig;
+  webpackConfigPath?: string;
+  serviceName?: string;
+  servePrefix?: string;
+  gateway?: GatewayConfig;
+  /** Plain-http listener straight to the children - service-to-service calls, no gateway middleware. */
+  internalPort?: number;
+}

package/executors/serve/schema.json

@@ -0,0 +1,196 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "DavnxWebpackServe",
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "continuous": true,
+  "title": "NestJS Webpack Serve",
+  "description": "Serve a NestJS application with webpack watch mode and integrated devserver.",
+  "cli": "nx",
+  "type": "object",
+  "properties": {
+    "entryFile": {
+      "type": "string",
+      "description": "Path to the main entry-point file, relative to project root.",
+      "x-completion-type": "file",
+      "x-completion-glob": "**/*@(.js|.ts)",
+      "x-priority": "important",
+      "default": "./src/deployments/service/main.ts"
+    },
+    "tsConfigFile": {
+      "type": "string",
+      "description": "Path to the TypeScript configuration file, relative to project root.",
+      "x-completion-type": "file",
+      "x-completion-glob": "tsconfig*.json",
+      "x-priority": "important",
+      "default": "./tsconfig.app.json"
+    },
+    "outputPath": {
+      "type": "string",
+      "description": "Output directory path, relative to workspace root.",
+      "x-completion-type": "directory"
+    },
+    "assets": {
+      "type": "array",
+      "description": "List of static assets to copy.",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "workers": {
+      "type": "array",
+      "description": "Worker entry points. Each produces a separate [name].js bundle compiled alongside the main entry in watch mode.",
+      "items": {
+        "type": "object",
+        "properties": {
+          "name": {
+            "type": "string",
+            "description": "Output filename (without .js extension)."
+          },
+          "entryPath": {
+            "type": "string",
+            "description": "Path to the worker entry file. './' paths are relative to project root, otherwise relative to workspace root."
+          }
+        },
+        "required": [
+          "name",
+          "entryPath"
+        ]
+      },
+      "default": []
+    },
+    "configEnv": {
+      "type": "string",
+      "description": "Environment name for config YAML resolution (config.{env}.yaml).",
+      "default": "development"
+    },
+    "memoryLimit": {
+      "type": "number",
+      "description": "Memory limit in MB for TypeScript type checker.",
+      "default": 8192
+    },
+    "childCount": {
+      "type": "number",
+      "description": "Number of child processes for the devserver.",
+      "default": 1
+    },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source.",
+      "default": true
+    },
+    "orgScopes": {
+      "type": "array",
+      "description": "Patterns to bundle rather than externalize. Supports 4 modes: org scope ('@myorg' → @myorg/*), prefix ('@myorg/prefix' → @myorg/prefix*), regex ('/^pattern/' → custom regex), exact package name ('lodash' → lodash and lodash/subpath).",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "bundlePackages": {
+      "type": "array",
+      "description": "Explicit package names to force-bundle into the output instead of externalizing (e.g. ['lodash', 'my-pkg']).",
+      "items": {
+        "type": "string"
+      },
+      "default": []
+    },
+    "nodeExternalsConfig": {
+      "type": "object",
+      "description": "Override options for webpack-node-externals. Merged with defaults — allowlist entries are appended to orgScopes and bundlePackages.",
+      "properties": {
+        "allowlist": {
+          "type": "array",
+          "description": "Additional patterns to allowlist (bundle instead of externalize).",
+          "items": {
+            "type": "string"
+          }
+        },
+        "additionalModuleDirs": {
+          "type": "array",
+          "description": "Additional directories to scan for modules to externalize.",
+          "items": {
+            "type": "string"
+          }
+        },
+        "importType": {
+          "type": "string",
+          "description": "Module import type for externalized packages (default: 'commonjs')."
+        }
+      }
+    },
+    "webpackConfigPath": {
+      "type": "string",
+      "description": "Path to a JS/TS file (relative to project root) that exports a (config) => config function for custom webpack overrides.",
+      "x-completion-type": "file",
+      "x-completion-glob": "webpack*@(.js|.ts)"
+    },
+    "serviceName": {
+      "type": "string",
+      "description": "Service name for config resolution and socket directory naming. Overrides the value from config YAML. Does not affect URL prefix — use servePrefix for that."
+    },
+    "servePrefix": {
+      "type": "string",
+      "description": "URL path prefix for the devserver (e.g. 'agenshield' → /agenshield/). Empty string means no prefix. Independent of serviceName.",
+      "default": ""
+    },
+    "gateway": {
+      "type": "object",
+      "description": "Dev gateway: pluggable request middleware, hostname/prefix routes to other dev servers, and optional basic-ssl HTTPS.",
+      "properties": {
+        "middleware": {
+          "type": "string",
+          "description": "Path to a JS file (relative to project root) that exports a function: (req: IncomingMessage, config: Record<string, unknown>) => void. Called before each request is proxied.",
+          "x-completion-type": "file"
+        },
+        "routes": {
+          "type": "array",
+          "description": "Front-gateway routes, matched in order by Host (exact or *.suffix wildcard) and/or URL prefix. With target -> proxied there (e.g. the vite dev server); without target -> this service's own children.",
+          "items": {
+            "type": "object",
+            "properties": {
+              "host": {
+                "type": "string",
+                "description": "Hostname to match - exact (api.tetros.localhost) or wildcard (*.tetros.localhost)."
+              },
+              "prefix": {
+                "type": "string",
+                "description": "URL prefix to match (e.g. /api)."
+              },
+              "target": {
+                "type": "string",
+                "description": "Proxy destination URL (e.g. http://localhost:5173). Omit to route to this service's children."
+              },
+              "prependPrefix": {
+                "type": "string",
+                "description": "Prepend this to the forwarded URL (e.g. /api) so a service mounted under a prefix is served at the ROOT of its dev domain — api.tetros.ai.local/tenants/... → children /api/tenants/... (prod parity with api.tetros.ai)."
+              }
+            },
+            "additionalProperties": false
+          }
+        },
+        "https": {
+          "type": "boolean",
+          "description": "Terminate TLS at the parent with a cached self-signed cert (@vitejs/plugin-basic-ssl style; SANs cover localhost, loopbacks and every route hostname). Zero config - browsers need a one-time trust confirmation."
+        },
+        "extraPorts": {
+          "type": "array",
+          "items": {
+            "type": "number"
+          },
+          "description": "Additional listener ports sharing the same routing/TLS — e.g. [443] so a dev domain works without :port in the URL (macOS allows unprivileged <1024 binds; failure to bind only warns)."
+        }
+      }
+    },
+    "internalPort": {
+      "type": "number",
+      "description": "Plain-http listener that proxies straight to this service children — no gateway routes, no gateway middleware (JWT). For service-to-service calls, mirroring cluster-internal networking."
+    }
+  },
+  "required": [
+    "entryFile",
+    "tsConfigFile"
+  ],
+  "additionalProperties": false
+}

package/executors/serve/serve.impl.d.ts

@@ -0,0 +1,25 @@
+import type { ServeExecutorSchema } from './schema';
+interface ExecutorContext {
+    root: string;
+    projectName?: string;
+    projectsConfigurations?: {
+        projects: Record<string, {
+            root: string;
+        }>;
+    };
+}
+/**
+ * Dev serve executor — webpack watch mode with integrated devserver.
+ *
+ * Owns the full devserver lifecycle:
+ * 1. Starts webpack in watch mode
+ * 2. On first successful build, forks main.devserver.js with proper env vars
+ * 3. On subsequent builds, POSTs /webpack/reload to devserver
+ * 4. On shutdown, cleans up devserver and webpack watcher
+ */
+declare function serveExecutor(options: ServeExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    baseUrl?: string;
+}>;
+export default serveExecutor;
+//# sourceMappingURL=serve.impl.d.ts.map

package/executors/serve/serve.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serve.impl.d.ts","sourceRoot":"","sources":["../../../../../libs/cluster/src/executors/serve/serve.impl.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAKpD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE;QACvB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE;YAAE,IAAI,EAAE,MAAM,CAAA;SAAE,CAAC,CAAC;KAC5C,CAAC;CACH;AAED;;;;;;;;GAQG;AACH,iBAAgB,aAAa,CAC3B,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC,CAoPxD;AAED,eAAe,aAAa,CAAC"}

package/executors/serve/serve.impl.js

@@ -0,0 +1,243 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const path = tslib_1.__importStar(require("node:path"));
+const fs = tslib_1.__importStar(require("node:fs"));
+const node_child_process_1 = require("node:child_process");
+const yaml = tslib_1.__importStar(require("js-yaml"));
+const create_webpack_dev_1 = require("../../create-webpack-dev");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const webpack = require('webpack');
+/**
+ * Dev serve executor — webpack watch mode with integrated devserver.
+ *
+ * Owns the full devserver lifecycle:
+ * 1. Starts webpack in watch mode
+ * 2. On first successful build, forks main.devserver.js with proper env vars
+ * 3. On subsequent builds, POSTs /webpack/reload to devserver
+ * 4. On shutdown, cleans up devserver and webpack watcher
+ */
+async function* serveExecutor(options, context) {
+    process.env.NODE_ENV = 'development';
+    const projectConfig = context.projectsConfigurations.projects[context.projectName];
+    const workspaceRoot = context.root;
+    const projectRoot = path.join(workspaceRoot, projectConfig.root);
+    const outputPath = options.outputPath
+        ? path.join(workspaceRoot, options.outputPath)
+        : path.join(workspaceRoot, 'dist', projectConfig.root);
+    // Resolve port and serviceName from config YAML
+    const configEnv = options.configEnv || 'development';
+    const configFilePath = path.join(workspaceRoot, 'config', `config.${configEnv}.yaml`);
+    let port = 3050;
+    let serviceName = context.projectName;
+    let yamlConfig = {};
+    if (fs.existsSync(configFilePath)) {
+        yamlConfig = yaml.load(fs.readFileSync(configFilePath, 'utf8'));
+        port = Number(yamlConfig.port) || port;
+        serviceName = yamlConfig.serviceName || serviceName;
+    }
+    if (options.serviceName) {
+        serviceName = options.serviceName;
+    }
+    const servePrefix = options.servePrefix ?? '';
+    // Resolve gateway middleware
+    let gatewayMiddlewarePath;
+    let gatewayConfigJson;
+    if (options.gateway?.middleware) {
+        gatewayMiddlewarePath = path.resolve(projectRoot, options.gateway.middleware);
+        gatewayConfigJson = JSON.stringify(yamlConfig);
+    }
+    // Resolve entry/tsconfig relative to project root (absolute paths avoid
+    // NxAppWebpackPlugin's normalizeRelativePaths collision with executor options)
+    const entryFile = options.entryFile || './src/deployments/service/main.ts';
+    const tsConfigFile = options.tsConfigFile || './tsconfig.app.json';
+    const resolvedMain = path.resolve(projectRoot, entryFile);
+    const resolvedTsConfig = path.resolve(projectRoot, tsConfigFile);
+    // Map workers to additional entry points
+    const additionalEntryPoints = (options.workers || []).map((w) => ({
+        entryName: w.name,
+        entryPath: path.resolve(projectRoot, w.entryPath),
+    }));
+    // Build dev webpack config
+    const config = (0, create_webpack_dev_1.createDevWebpackConfig)({
+        appName: context.projectName,
+        appRoot: projectRoot,
+        outputDir: outputPath,
+        main: resolvedMain,
+        tsConfig: resolvedTsConfig,
+        assets: options.assets || [],
+        additionalEntryPoints,
+        port,
+        serviceName,
+        memoryLimit: options.memoryLimit || 8192,
+        buildLibsFromSource: options.buildLibsFromSource !== false,
+        workspaceRoot,
+        orgScopes: options.orgScopes || [],
+        bundlePackages: options.bundlePackages || [],
+        nodeExternalsConfig: options.nodeExternalsConfig,
+        webpackConfigPath: options.webpackConfigPath,
+        httpsReload: options.gateway?.https === true,
+    });
+    // State
+    let devserverProcess = null;
+    let firstBuildComplete = false;
+    // Path to the devserver script — resolve JS first, fall back to TS (local dev with swc-node)
+    const devserverScriptJs = path.join(__dirname, '../../main.devserver.js');
+    const devserverScriptTs = path.join(__dirname, '../../main.devserver.ts');
+    const runningFromSource = !fs.existsSync(devserverScriptJs) && fs.existsSync(devserverScriptTs);
+    const devserverScript = runningFromSource ? devserverScriptTs : devserverScriptJs;
+    // Absolute path to the webpack bundle the devserver should load
+    const bundlePath = path.join(outputPath, 'main.js');
+    function cleanup() {
+        if (devserverProcess && !devserverProcess.killed) {
+            devserverProcess.kill('SIGTERM');
+            devserverProcess = null;
+        }
+    }
+    // Register cleanup on process signals
+    const signals = ['SIGINT', 'SIGTERM', 'SIGHUP', 'SIGQUIT'];
+    const signalHandlers = signals.map((sig) => {
+        const handler = () => cleanup();
+        process.on(sig, handler);
+        return { sig, handler };
+    });
+    process.on('exit', cleanup);
+    function startDevServer() {
+        if (!fs.existsSync(devserverScript)) {
+            console.error(`[serve] devserver script not found at ${devserverScript}`);
+            return;
+        }
+        const execArgv = ['--enable-source-maps'];
+        if (runningFromSource) {
+            execArgv.unshift('--require', '@swc-node/register');
+        }
+        devserverProcess = (0, node_child_process_1.fork)(devserverScript, {
+            cwd: workspaceRoot,
+            env: {
+                ...process.env,
+                PORT: String(port),
+                SERVICE_NAME: serviceName,
+                SERVE_PREFIX: servePrefix,
+                // Zero-touch lens identity + bus for pod children and workers: the
+                // injected @lensmcp/node-instrumentation (and the grafted nest module)
+                // attribute every event to this project and write to the shared file
+                // rendezvous — without these, nest trace events fall to the console
+                // sink and are lost in cluster mode.
+                LENSMCP_PROJECT: process.env.LENSMCP_PROJECT || context.projectName || serviceName,
+                LENSMCP_EVENT_FILE: process.env.LENSMCP_EVENT_FILE || path.join(workspaceRoot, '.lensmcp', 'events.jsonl'),
+                CHILD_COUNT: String(options.childCount || process.env.CHILD_COUNT || 1),
+                BUNDLE_PATH: bundlePath,
+                ...(gatewayMiddlewarePath && { GATEWAY_MIDDLEWARE: gatewayMiddlewarePath }),
+                ...(gatewayConfigJson && { GATEWAY_CONFIG: gatewayConfigJson }),
+                ...(options.gateway?.routes?.length && { GATEWAY_ROUTES: JSON.stringify(options.gateway.routes) }),
+                ...(options.gateway?.https && { GATEWAY_HTTPS: "1" }),
+                ...(options.gateway?.extraPorts?.length && { GATEWAY_EXTRA_PORTS: JSON.stringify(options.gateway.extraPorts) }),
+                ...(options.internalPort && { INTERNAL_PORT: String(options.internalPort) }),
+                ...((options.workers?.length) && { WORKERS: JSON.stringify(options.workers.map(w => w.name)) }),
+            },
+            stdio: ['inherit', 'inherit', 'inherit', 'ipc'],
+            execArgv,
+        });
+        devserverProcess.on('exit', (code, signal) => {
+            devserverProcess = null;
+            if (signal)
+                return; // ANY signal = intentional kill (TERM/INT/KILL) — never respawn a corpse
+            console.error(`[serve] devserver exited unexpectedly (code=${code}, signal=${signal}) — respawning in 1.5s`);
+            // Supervision: the watcher may sit idle (no rebuild event) forever —
+            // without this the service stays podless until a source edit.
+            setTimeout(() => {
+                if (!devserverProcess && firstBuildComplete)
+                    startDevServer();
+            }, 1500).unref?.();
+        });
+        console.log(`[serve] Devserver started on port ${port} (service: ${serviceName}${servePrefix ? `, prefix: /${servePrefix}` : ''})`);
+    }
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    function _notifyDevServerReload() {
+        if (!devserverProcess || devserverProcess.killed) {
+            console.log('[serve] Devserver not running, restarting...');
+            startDevServer();
+            return;
+        }
+        fetch(`http://localhost:${port}/webpack/reload`, {
+            method: 'POST',
+            headers: { 'content-type': 'application/json' },
+            body: '{}',
+        })
+            .then(() => console.log('[serve] Notified devserver to reload'))
+            .catch((err) => {
+            console.warn('[serve] Failed to notify devserver, restarting...', err.message);
+            cleanup();
+            startDevServer();
+        });
+    }
+    // Start webpack in watch mode
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    const { watch: _watch, ...normalizedConfig } = config;
+    const compiler = webpack(normalizedConfig);
+    // Event queue for the async generator
+    let resolveNext = null;
+    const pendingResults = [];
+    function pushResult(result) {
+        if (resolveNext) {
+            const resolve = resolveNext;
+            resolveNext = null;
+            resolve(result);
+        }
+        else {
+            pendingResults.push(result);
+        }
+    }
+    function waitForNext() {
+        if (pendingResults.length > 0) {
+            return Promise.resolve(pendingResults.shift());
+        }
+        return new Promise((resolve) => { resolveNext = resolve; });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const watching = compiler.watch(config.watchOptions || {}, (err, stats) => {
+        if (err) {
+            console.error('[serve] Webpack error:', err);
+            pushResult({ success: false });
+            return;
+        }
+        const hasErrors = stats.hasErrors();
+        console.info(stats.toString({ colors: true, chunks: false, assets: true }));
+        if (hasErrors) {
+            // Don't kill the devserver — keep the last good build running
+            pushResult({ success: false });
+            return;
+        }
+        if (!firstBuildComplete || !devserverProcess) {
+            // first SUCCESSFUL build (a failed first compile must not strand the
+            // service devserver-less forever), or the devserver died while webpack
+            // recovered — fork it now.
+            firstBuildComplete = true;
+            startDevServer();
+        }
+        // Note: subsequent reloads are handled by DevServerReloadPlugin in webpack config
+        // which POSTs to /webpack/reload. We don't need to do it here since the plugin fires
+        // after each successful build.
+        pushResult({
+            success: true,
+            baseUrl: `http://localhost:${port}`,
+        });
+    });
+    // Main generator loop: yield each build result
+    try {
+        while (true) {
+            const result = await waitForNext();
+            yield result;
+        }
+    }
+    finally {
+        // Generator was returned/thrown (Nx killed the executor)
+        watching.close(() => { });
+        cleanup();
+        // Remove signal handlers
+        signalHandlers.forEach(({ sig, handler }) => process.removeListener(sig, handler));
+    }
+}
+exports.default = serveExecutor;
+module.exports = serveExecutor;
+module.exports.default = serveExecutor;

package/executors/trust/schema.d.ts

@@ -0,0 +1,6 @@
+export interface TrustExecutorSchema {
+  /** Target whose gateway.routes hostnames should be set up. Default `serve-hmr`. */
+  serveTarget?: string;
+  /** Extra hostnames to add to /etc/hosts beyond the route hostnames. */
+  hosts?: string[];
+}

package/executors/trust/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "version": 2,
+  "title": "Trust executor",
+  "description": "One-time local HTTPS setup for the dev gateway: trusts the davnx local CA in the OS keychain and writes /etc/hosts entries (127.0.0.1 + ::1) for every gateway route hostname. Idempotent; run from a terminal so sudo can prompt.",
+  "type": "object",
+  "properties": {
+    "serveTarget": {
+      "type": "string",
+      "description": "Target whose gateway.routes hostnames should be set up. Default: serve-hmr.",
+      "default": "serve-hmr"
+    },
+    "hosts": {
+      "type": "array",
+      "items": { "type": "string" },
+      "description": "Extra hostnames to add to /etc/hosts beyond the route hostnames."
+    }
+  },
+  "additionalProperties": false
+}

package/executors/trust/trust.impl.d.ts

@@ -0,0 +1,42 @@
+import type { TrustExecutorSchema } from './schema';
+interface ExecutorContext {
+    root: string;
+    projectName?: string;
+    projectsConfigurations?: {
+        projects: Record<string, {
+            root: string;
+            targets?: Record<string, {
+                options?: {
+                    gateway?: {
+                        routes?: Array<{
+                            host?: string;
+                        }>;
+                    };
+                };
+            }>;
+        }>;
+    };
+}
+/**
+ * `trust` executor — one idempotent command that makes the HTTPS dev gateway
+ * green in real browsers:
+ *
+ *   1. mints the local dev CA if missing (same CA the gateway serves),
+ *   2. adds it ONCE to the macOS System keychain (`sudo security
+ *      add-trusted-cert`) — every leaf rotation / new hostname then chains
+ *      to it with no interstitial,
+ *   3. writes BOTH `/etc/hosts` families (`127.0.0.1` + `::1`) for every
+ *      gateway route hostname — the missing `::1` line is what sends `.local`
+ *      AAAA lookups to Bonjour/mDNS and costs ~5s per resolution,
+ *   4. flushes the DNS cache.
+ *
+ * Hostnames come from the project's serve target gateway routes (wildcards
+ * skipped — they can't live in /etc/hosts) plus any `hosts` option extras.
+ * Run it from a terminal: sudo prompts for your password inline.
+ */
+export default function trustExecutor(options: TrustExecutorSchema, context: ExecutorContext): Promise<{
+    success: boolean;
+}>;
+export declare function collectHosts(options: TrustExecutorSchema, context: ExecutorContext): string[];
+export {};
+//# sourceMappingURL=trust.impl.d.ts.map

package/executors/trust/trust.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trust.impl.d.ts","sourceRoot":"","sources":["../../../../../libs/cluster/src/executors/trust/trust.impl.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAEpD,UAAU,eAAe;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,CAAC,EAAE;QACvB,QAAQ,EAAE,MAAM,CACd,MAAM,EACN;YACE,IAAI,EAAE,MAAM,CAAC;YACb,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE;gBAAE,OAAO,CAAC,EAAE;oBAAE,OAAO,CAAC,EAAE;wBAAE,MAAM,CAAC,EAAE,KAAK,CAAC;4BAAE,IAAI,CAAC,EAAE,MAAM,CAAA;yBAAE,CAAC,CAAA;qBAAE,CAAA;iBAAE,CAAA;aAAE,CAAC,CAAC;SAC7F,CACF,CAAC;KACH,CAAC;CACH;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAA8B,aAAa,CACzC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAwE/B;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,mBAAmB,EAAE,OAAO,EAAE,eAAe,GAAG,MAAM,EAAE,CAiC7F"}