@lensmcp/cluster 1.0.0

package/create-webpack-dev.js

@@ -0,0 +1,151 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDevWebpackConfig = createDevWebpackConfig;
+const tslib_1 = require("tslib");
+const app_plugin_1 = require("@nx/webpack/app-plugin");
+const fs = tslib_1.__importStar(require("node:fs"));
+const path = tslib_1.__importStar(require("node:path"));
+const webpack_node_externals_1 = tslib_1.__importDefault(require("webpack-node-externals"));
+const build_scope_patterns_1 = require("./build-scope-patterns");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const webpack = require('webpack');
+class DevServerReloadPlugin {
+    constructor(port, secure = false) {
+        // When the parent terminates TLS (gateway.https), notify over https with the
+        // self-signed cert accepted — the cert is ours (basic-ssl style, cached locally).
+        this.secure = secure;
+        this.url = `${secure ? 'https' : 'http'}://localhost:${port}/webpack/reload`;
+    }
+    notify() {
+        return new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            const mod = (this.secure ? require('node:https') : require('node:http'));
+            const req = mod.request(this.url, { method: 'POST', headers: { 'content-type': 'application/json' }, rejectUnauthorized: false }, (res) => { res.resume(); res.on('end', resolve); });
+            req.on('error', reject);
+            req.end('{}');
+        });
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    apply(compiler) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        compiler.hooks.done.tap('DevServerReloadPlugin', async (stats) => {
+            try {
+                if (stats.hasErrors())
+                    return;
+                await this.notify();
+                console.log('[DevServerReloadPlugin] notified devserver to reload');
+            }
+            catch {
+                console.log('[DevServerReloadPlugin] devserver not running yet');
+            }
+        });
+    }
+}
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function createDevWebpackConfig(options) {
+    const { appRoot, outputDir, main, tsConfig, workspaceRoot, assets = [], port, memoryLimit = 8192, buildLibsFromSource = true, orgScopes = [], bundlePackages = [], additionalEntryPoints = [], nodeExternalsConfig: userNodeExternalsConfig, webpackConfigPath, } = options;
+    const { allowlistPatterns, scopePrefixes, scopePatterns } = (0, build_scope_patterns_1.buildScopePatterns)(orgScopes);
+    // Build combined allowlist: orgScopes + bundlePackages + user-provided
+    const bundlePatterns = bundlePackages.map((pkg) => new RegExp(`^${pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(/|$)`));
+    const combinedAllowlist = [
+        /webpack\/hot\/poll\?100/,
+        ...allowlistPatterns,
+        ...bundlePatterns,
+        ...(userNodeExternalsConfig?.allowlist || []),
+    ];
+    const config = {
+        output: {
+            path: outputDir,
+            ...(process.env.NODE_ENV !== 'production' && {
+                devtoolModuleFilenameTemplate: '[absolute-resource-path]',
+            }),
+            clean: true,
+        },
+        externals: [
+            (0, webpack_node_externals_1.default)({
+                allowlist: combinedAllowlist,
+                additionalModuleDirs: userNodeExternalsConfig?.additionalModuleDirs || [],
+                ...(userNodeExternalsConfig?.importType && { importType: userNodeExternalsConfig.importType }),
+            }),
+            ({ request }, callback) => {
+                // Workspace-internal absolute requests are SOURCE regardless of the
+                // bucket layout (apps/, libs/, server/, shared/, web/, …) — bundle them.
+                // The apps/libs prefix checks below stay for explicitness/back-compat.
+                if (request &&
+                    path.isAbsolute(request) &&
+                    request.startsWith(workspaceRoot) &&
+                    !request.includes('node_modules')) {
+                    return callback();
+                }
+                if (request &&
+                    (request.startsWith(path.join(workspaceRoot, 'apps')) ||
+                        request.startsWith(path.join(workspaceRoot, 'libs')))) {
+                    return callback();
+                }
+                if (request && scopePrefixes.some((prefix) => request.startsWith(prefix))) {
+                    return callback();
+                }
+                if (request && scopePatterns.some((pattern) => pattern.test(request))) {
+                    return callback();
+                }
+                if (request && bundlePatterns.some((pattern) => pattern.test(request))) {
+                    return callback();
+                }
+                if (request && !(request.startsWith('./') || request.startsWith('..'))) {
+                    // Bare specifier: only a real node_modules package may stay external —
+                    // tsconfig-path aliases (e.g. @org/contracts → workspace source) must bundle.
+                    const rootSegment = request.startsWith('@')
+                        ? request.split('/').slice(0, 2).join('/')
+                        : request.split('/')[0];
+                    if (!fs.existsSync(path.join(workspaceRoot, 'node_modules', rootSegment))) {
+                        return callback();
+                    }
+                    return callback(null, `commonjs ${request}`);
+                }
+                return callback();
+            },
+        ],
+        mode: 'development',
+        devtool: 'eval-cheap-module-source-map',
+        plugins: [
+            new webpack.HotModuleReplacementPlugin(),
+            new app_plugin_1.NxAppWebpackPlugin({
+                target: 'node22',
+                compiler: 'tsc',
+                main,
+                additionalEntryPoints,
+                verbose: true,
+                sourceMap: 'eval-cheap-module-source-map',
+                mergeExternals: true,
+                externalDependencies: [],
+                memoryLimit,
+                tsConfig,
+                assets,
+                optimization: false,
+                progress: false,
+                outputHashing: 'none',
+                generatePackageJson: false,
+                watchDependencies: true,
+                typeCheckOptions: {
+                    async: true,
+                },
+                buildLibsFromSource,
+            }),
+            new DevServerReloadPlugin(port, options.httpsReload === true),
+        ],
+        snapshot: { managedPaths: [/^(.+?[\\/])?node_modules[\\/]/] },
+        watch: true,
+        watchOptions: {
+            ignored: ['**/*.env.template', '**/config.template.json', '**/*.md', '**/dist/**', '**/migrations/**'],
+        },
+        cache: { type: 'filesystem' },
+    };
+    // Apply user webpack overrides if configured
+    if (webpackConfigPath) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const overrideModule = require(path.resolve(appRoot, webpackConfigPath));
+        const overrideFn = overrideModule.default || overrideModule;
+        return overrideFn(config);
+    }
+    return config;
+}

package/create-webpack-prod.d.ts

@@ -0,0 +1,28 @@
+import { type NodeExternalsConfig } from './build-scope-patterns';
+type Configuration = Record<string, any>;
+export interface ProdWebpackOptions {
+    appName: string;
+    appRoot: string;
+    outputDir: string;
+    main: string;
+    tsConfig: string;
+    workspaceRoot: string;
+    assets?: string[];
+    additionalEntryPoints?: Array<{
+        entryName: string;
+        entryPath: string;
+    }>;
+    runtimeDependencies?: string[];
+    memoryLimit?: number;
+    generatePackageJson?: boolean;
+    buildLibsFromSource?: boolean;
+    ormConfigPath?: string;
+    migrationsDir?: string;
+    orgScopes?: string[];
+    bundlePackages?: string[];
+    nodeExternalsConfig?: NodeExternalsConfig;
+    webpackConfigPath?: string;
+}
+export declare function createProdWebpackConfig(options: ProdWebpackOptions): Configuration[];
+export {};
+//# sourceMappingURL=create-webpack-prod.d.ts.map

package/create-webpack-prod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-webpack-prod.d.ts","sourceRoot":"","sources":["../../../libs/cluster/src/create-webpack-prod.ts"],"names":[],"mappings":"AAKA,OAAO,EAAsB,KAAK,mBAAmB,EAAE,MAAM,wBAAwB,CAAC;AAMtF,KAAK,aAAa,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;AAEzC,MAAM,WAAW,kBAAkB;IACjC,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;IAClB,qBAAqB,CAAC,EAAE,KAAK,CAAC;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IACxE,mBAAmB,CAAC,EAAE,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,mBAAmB,CAAC,EAAE,OAAO,CAAC;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,cAAc,CAAC,EAAE,MAAM,EAAE,CAAC;IAC1B,mBAAmB,CAAC,EAAE,mBAAmB,CAAC;IAC1C,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAED,wBAAgB,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG,aAAa,EAAE,CAiMpF"}

package/create-webpack-prod.js

@@ -0,0 +1,169 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createProdWebpackConfig = createProdWebpackConfig;
+const tslib_1 = require("tslib");
+const app_plugin_1 = require("@nx/webpack/app-plugin");
+const fs = tslib_1.__importStar(require("node:fs"));
+const path = tslib_1.__importStar(require("node:path"));
+const glob_1 = require("glob");
+const webpack_node_externals_1 = tslib_1.__importDefault(require("webpack-node-externals"));
+const build_scope_patterns_1 = require("./build-scope-patterns");
+function createProdWebpackConfig(options) {
+    const { appRoot, outputDir, main, tsConfig, workspaceRoot, assets = [], additionalEntryPoints = [], runtimeDependencies = [], memoryLimit = 8192, generatePackageJson = true, buildLibsFromSource = false, ormConfigPath, migrationsDir = './src/migrations', orgScopes = [], bundlePackages = [], nodeExternalsConfig: userNodeExternalsConfig, webpackConfigPath, } = options;
+    const { allowlistPatterns, scopePrefixes, scopePatterns } = (0, build_scope_patterns_1.buildScopePatterns)(orgScopes);
+    // Build combined allowlist: orgScopes + bundlePackages + user-provided
+    const bundlePatterns = bundlePackages.map((pkg) => new RegExp(`^${pkg.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}(/|$)`));
+    const combinedAllowlist = [
+        ...allowlistPatterns,
+        ...bundlePatterns,
+        ...(userNodeExternalsConfig?.allowlist || []),
+    ];
+    // Detect ormconfig.ts for the app so we can build it for TypeORM CLI in production
+    let resolvedOrmConfigPath;
+    if (ormConfigPath !== undefined) {
+        resolvedOrmConfigPath = ormConfigPath ? path.join(appRoot, ormConfigPath) : null;
+    }
+    else {
+        const candidate = path.join(appRoot, './src/ormconfig.ts');
+        resolvedOrmConfigPath = fs.existsSync(candidate) ? candidate : null;
+    }
+    const hasOrmconfig = resolvedOrmConfigPath && fs.existsSync(resolvedOrmConfigPath);
+    const webpackConfigs = [];
+    const externalsConfig = [
+        (0, webpack_node_externals_1.default)({
+            allowlist: combinedAllowlist,
+            additionalModuleDirs: userNodeExternalsConfig?.additionalModuleDirs || [],
+            ...(userNodeExternalsConfig?.importType && { importType: userNodeExternalsConfig.importType }),
+        }),
+        ({ request }, callback) => {
+            // Workspace-internal absolute requests are SOURCE regardless of the
+            // bucket layout (apps/, libs/, server/, shared/, web/, …) — bundle them.
+            if (request &&
+                path.isAbsolute(request) &&
+                request.startsWith(workspaceRoot) &&
+                !request.includes('node_modules')) {
+                return callback();
+            }
+            if (request &&
+                (request.startsWith(path.join(workspaceRoot, 'apps')) ||
+                    request.startsWith(path.join(workspaceRoot, 'libs')))) {
+                return callback();
+            }
+            if (request && scopePrefixes.some((prefix) => request.startsWith(prefix))) {
+                return callback();
+            }
+            if (request && scopePatterns.some((pattern) => pattern.test(request))) {
+                return callback();
+            }
+            if (request && bundlePatterns.some((pattern) => pattern.test(request))) {
+                return callback();
+            }
+            if (request && !(request.startsWith('./') || request.startsWith('..'))) {
+                // Bare specifier: only a real node_modules package may stay external —
+                // tsconfig-path aliases (e.g. @org/contracts → workspace source) must bundle.
+                const rootSegment = request.startsWith('@')
+                    ? request.split('/').slice(0, 2).join('/')
+                    : request.split('/')[0];
+                if (!fs.existsSync(path.join(workspaceRoot, 'node_modules', rootSegment))) {
+                    return callback();
+                }
+                return callback(null, `commonjs ${request}`);
+            }
+            return callback();
+        },
+    ];
+    const productionBuildConfig = {
+        externals: externalsConfig,
+        output: {
+            path: outputDir,
+            clean: false,
+        },
+        devtool: 'inline-source-map',
+        mode: 'production',
+        plugins: [
+            new app_plugin_1.NxAppWebpackPlugin({
+                target: 'node22',
+                compiler: 'tsc',
+                main,
+                additionalEntryPoints,
+                externalDependencies: [],
+                mergeExternals: true,
+                memoryLimit,
+                tsConfig,
+                assets,
+                namedChunks: true,
+                optimization: true,
+                outputHashing: 'none',
+                generatePackageJson,
+                runtimeDependencies,
+                buildLibsFromSource,
+                typeCheckOptions: {
+                    async: false,
+                },
+                sourceMap: 'inline-source-map',
+                progress: false,
+            }),
+        ],
+    };
+    webpackConfigs.push(productionBuildConfig);
+    if (hasOrmconfig && resolvedOrmConfigPath) {
+        const migrationsEntryPoints = [];
+        const migrationsGlobPath = path.join(appRoot, migrationsDir, '*.ts');
+        const migrationFiles = (0, glob_1.globSync)(migrationsGlobPath);
+        migrationFiles.forEach((filename) => {
+            const migrationName = path.basename(filename, '.ts');
+            migrationsEntryPoints.push({
+                entryName: `migrations/${migrationName}`,
+                entryPath: filename,
+            });
+        });
+        const ormconfigRelative = './' + path.relative(appRoot, resolvedOrmConfigPath);
+        const ormconfigBuildConfig = {
+            ...productionBuildConfig,
+            output: {
+                ...productionBuildConfig.output,
+                filename: (pathData) => {
+                    if (pathData.runtime === 'main') {
+                        return 'ormconfig.js';
+                    }
+                    return '[name].js';
+                },
+                library: {
+                    type: 'commonjs',
+                },
+                clean: false,
+            },
+            devtool: false,
+            plugins: [
+                new app_plugin_1.NxAppWebpackPlugin({
+                    target: 'node22',
+                    compiler: 'tsc',
+                    main: ormconfigRelative,
+                    externalDependencies: [],
+                    additionalEntryPoints: migrationsEntryPoints,
+                    mergeExternals: true,
+                    tsConfig,
+                    assets: [],
+                    namedChunks: true,
+                    memoryLimit,
+                    optimization: false,
+                    outputHashing: 'none',
+                    generatePackageJson: false,
+                    buildLibsFromSource,
+                    skipTypeChecking: true,
+                    sourceMap: false,
+                    progress: !process.env.CI,
+                }),
+            ],
+        };
+        webpackConfigs.push(ormconfigBuildConfig);
+    }
+    // Apply user webpack overrides if configured
+    if (webpackConfigPath) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const overrideModule = require(path.resolve(appRoot, webpackConfigPath));
+        const overrideFn = overrideModule.default || overrideModule;
+        return webpackConfigs.map((config) => overrideFn(config));
+    }
+    return webpackConfigs;
+}

package/executors/build/build.impl.d.ts

@@ -0,0 +1,19 @@
+import type { BuildExecutorSchema } from './schema';
+interface ExecutorContext {
+    root: string;
+    projectName?: string;
+    projectsConfigurations?: {
+        projects: Record<string, {
+            root: string;
+        }>;
+    };
+}
+/**
+ * Production webpack build executor for NestJS applications.
+ */
+declare function buildExecutor(options: BuildExecutorSchema, context: ExecutorContext): AsyncGenerator<{
+    success: boolean;
+    outfile?: string;
+}>;
+export default buildExecutor;
+//# sourceMappingURL=build.impl.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"build.impl.d.ts","sourceRoot":"","sources":["../../../../../libs/cluster/src/executors/build/build.impl.ts"],"names":[],"mappings":"AAGA,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;;GAEG;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,CA2FxD;AAED,eAAe,aAAa,CAAC"}

package/executors/build/build.impl.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("node:fs"));
+const path = tslib_1.__importStar(require("node:path"));
+const create_webpack_prod_1 = require("../../create-webpack-prod");
+// eslint-disable-next-line @typescript-eslint/no-require-imports
+const webpack = require('webpack');
+/**
+ * Production webpack build executor for NestJS applications.
+ */
+async function* buildExecutor(options, context) {
+    process.env.NODE_ENV = 'production';
+    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 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);
+    const configs = (0, create_webpack_prod_1.createProdWebpackConfig)({
+        appName: context.projectName,
+        appRoot: projectRoot,
+        outputDir: outputPath,
+        main: resolvedMain,
+        tsConfig: resolvedTsConfig,
+        assets: options.assets || [],
+        additionalEntryPoints: [
+            ...(options.workers || []).map((w) => ({ entryName: w.name, entryPath: w.entryPath })),
+            ...(options.additionalEntryPoints || []),
+        ],
+        runtimeDependencies: options.runtimeDependencies || [],
+        memoryLimit: options.memoryLimit || 8192,
+        generatePackageJson: options.generatePackageJson !== false,
+        buildLibsFromSource: options.buildLibsFromSource || false,
+        ormConfigPath: options.ormConfigPath,
+        migrationsDir: options.migrationsDir || './src/migrations',
+        workspaceRoot,
+        orgScopes: options.orgScopes || [],
+        bundlePackages: options.bundlePackages || [],
+        nodeExternalsConfig: options.nodeExternalsConfig,
+        webpackConfigPath: options.webpackConfigPath,
+    });
+    const configArray = Array.isArray(configs) ? configs : [configs];
+    for (const config of configArray) {
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+        const { watch: _watch, ...normalizedConfig } = config;
+        const compiler = webpack(normalizedConfig);
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const stats = await new Promise((resolve, reject) => {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            compiler.run((err, stats) => {
+                if (err)
+                    return reject(err);
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                compiler.close((closeErr) => {
+                    if (closeErr)
+                        console.error('[build] webpack close error:', closeErr);
+                });
+                resolve(stats);
+            });
+        });
+        console.info(stats.toString(config.stats || { colors: true, chunks: false }));
+        if (stats.hasErrors()) {
+            yield { success: false };
+            return;
+        }
+    }
+    // Post-process: minify worker outputs (NxAppWebpackPlugin doesn't minify additional entries)
+    const workerEntries = options.workers || [];
+    if (workerEntries.length > 0) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const { minify } = require('terser');
+        for (const worker of workerEntries) {
+            const filePath = path.join(outputPath, `${worker.name}.js`);
+            if (fs.existsSync(filePath)) {
+                const code = fs.readFileSync(filePath, 'utf-8');
+                const result = await minify(code, {
+                    keep_classnames: true,
+                    sourceMap: { content: 'inline', url: 'inline' },
+                });
+                if (result.code) {
+                    fs.writeFileSync(filePath, result.code);
+                    console.info(`[build] minified ${worker.name}.js`);
+                }
+            }
+        }
+    }
+    yield { success: true, outfile: path.join(outputPath, 'main.js') };
+}
+exports.default = buildExecutor;
+module.exports = buildExecutor;
+module.exports.default = buildExecutor;

package/executors/build/schema.d.ts

@@ -0,0 +1,35 @@
+export interface WorkerEntryPoint {
+  name: string;
+  entryPath: string;
+}
+
+export interface AdditionalEntryPoint {
+  entryName: string;
+  entryPath: string;
+}
+
+export interface NodeExternalsConfig {
+  allowlist?: string[];
+  additionalModuleDirs?: string[];
+  importType?: string;
+}
+
+export interface BuildExecutorSchema {
+  entryFile: string;
+  tsConfigFile: string;
+  outputPath?: string;
+  assets?: string[];
+  workers?: WorkerEntryPoint[];
+  /** @deprecated Use `workers` instead. */
+  additionalEntryPoints?: AdditionalEntryPoint[];
+  runtimeDependencies?: string[];
+  ormConfigPath?: string;
+  migrationsDir?: string;
+  memoryLimit?: number;
+  generatePackageJson?: boolean;
+  buildLibsFromSource?: boolean;
+  orgScopes?: string[];
+  bundlePackages?: string[];
+  nodeExternalsConfig?: NodeExternalsConfig;
+  webpackConfigPath?: string;
+}

package/executors/build/schema.json

@@ -0,0 +1,135 @@
+{
+  "$schema": "https://json-schema.org/schema",
+  "$id": "DavnxWebpackBuild",
+  "version": 2,
+  "outputCapture": "direct-nodejs",
+  "title": "NestJS Webpack Build",
+  "description": "Build a NestJS application using webpack.",
+  "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 self-contained, minified [name].js bundle.",
+      "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": []
+    },
+    "additionalEntryPoints": {
+      "type": "array",
+      "description": "Additional webpack entry points (deprecated, use 'workers' instead).",
+      "x-deprecated": "Use 'workers' instead.",
+      "items": {
+        "type": "object",
+        "properties": {
+          "entryName": { "type": "string" },
+          "entryPath": { "type": "string" }
+        }
+      },
+      "default": []
+    },
+    "runtimeDependencies": {
+      "type": "array",
+      "description": "Runtime dependencies to include in generated package.json.",
+      "items": { "type": "string" },
+      "default": []
+    },
+    "ormConfigPath": {
+      "type": "string",
+      "description": "Path to ormconfig.ts relative to project root. Auto-detected from src/ormconfig.ts if not specified."
+    },
+    "migrationsDir": {
+      "type": "string",
+      "description": "Path to migrations directory relative to project root.",
+      "default": "./src/migrations"
+    },
+    "memoryLimit": {
+      "type": "number",
+      "description": "Memory limit in MB for TypeScript type checker.",
+      "default": 8192
+    },
+    "generatePackageJson": {
+      "type": "boolean",
+      "description": "Generate package.json in output.",
+      "default": true
+    },
+    "buildLibsFromSource": {
+      "type": "boolean",
+      "description": "Read buildable libraries from source.",
+      "default": false
+    },
+    "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)"
+    }
+  },
+  "required": ["entryFile", "tsConfigFile"],
+  "additionalProperties": false
+}

package/executors/gateway/gateway.impl.d.ts

@@ -0,0 +1,23 @@
+import type { GatewayExecutorSchema } from './schema';
+import { type GatewayContext } from './gateway.lib';
+/**
+ * `gateway` executor — ONE https front door for the whole workspace,
+ * assembled dynamically from every project's `cluster` declaration:
+ *
+ *   "cluster": { "host": "api.tetros.ai.local", "service": "api", "prependPrefix": "/api" }
+ *   "cluster": { "host": "tetros.ai.local", "port": 5173, "default": true }
+ *
+ * Socket-pool services get production-shaped treatment: the gateway is the
+ * load balancer, round-robining each request across the service's child
+ * sockets (the pods), with serverless lifecycle (eager/minPods/maxPods/
+ * idleKillSec) and an auto `internal.<host>` domain for east-west calls
+ * that bypass the middleware (JWT) — a full prod demo on localhost. All of
+ * it is published to the LensMCP bus (source `gateway`, category `cluster`).
+ *
+ * The runtime lives in `gateway.lib.ts` (`startGateway`) so it is testable
+ * without signals; this wrapper only adds the executor contract.
+ */
+export default function gatewayExecutor(options: GatewayExecutorSchema, context: GatewayContext): Promise<{
+    success: boolean;
+}>;
+//# sourceMappingURL=gateway.impl.d.ts.map