@nu-art/build-and-install 0.401.0 → 0.401.1

package/exports/IndicesMcpServer.d.ts

@@ -0,0 +1,22 @@
+import { ProjectUnit } from '../units/base/ProjectUnit.js';
+import { Logger } from '@nu-art/ts-common';
+export declare class IndicesMcpServer extends Logger {
+    private server?;
+    private port;
+    private projectRoot;
+    private packages;
+    constructor(port: number, projectRoot: string, packages: ProjectUnit[]);
+    start(): Promise<void>;
+    stop(): Promise<void>;
+    private handleRequest;
+    private handleHealth;
+    private handlePackages;
+    private handlePackageRoutes;
+    private handleGetAllExports;
+    private handleGetByName;
+    private handleGetByFile;
+    private handleGetByType;
+    private handleStale;
+    private sendJson;
+    private sendError;
+}

package/exports/IndicesMcpServer.js

@@ -0,0 +1,220 @@
+import { createServer } from 'http';
+import { URL } from 'url';
+import { ExportIndexCache } from './ExportIndexCache.js';
+import { Unit_TypescriptLib } from '../units/implementations/Unit_TypescriptLib.js';
+import { Logger } from '@nu-art/ts-common';
+export class IndicesMcpServer extends Logger {
+    server;
+    port;
+    projectRoot;
+    packages;
+    constructor(port, projectRoot, packages) {
+        super();
+        this.port = port;
+        this.projectRoot = projectRoot;
+        this.packages = packages;
+    }
+    async start() {
+        return new Promise((resolve, reject) => {
+            this.server = createServer((req, res) => this.handleRequest(req, res));
+            this.server.listen(this.port, () => {
+                this.logInfo(`Export Indices MCP Server started on port ${this.port}`);
+                this.logInfo(`Available packages: ${this.packages.map(p => p.config.key).join(', ')}`);
+                resolve();
+            });
+            this.server.on('error', (error) => {
+                if (error.code === 'EADDRINUSE') {
+                    this.logError(`Port ${this.port} is already in use`);
+                    reject(new Error(`Port ${this.port} is already in use`));
+                }
+                else {
+                    this.logError('Server error:', error);
+                    reject(error);
+                }
+            });
+        });
+    }
+    async stop() {
+        return new Promise((resolve) => {
+            if (!this.server) {
+                resolve();
+                return;
+            }
+            this.server.close(() => {
+                this.logInfo('Export Indices MCP Server stopped');
+                resolve();
+            });
+        });
+    }
+    async handleRequest(req, res) {
+        try {
+            const url = new URL(req.url || '/', `http://${req.headers.host}`);
+            const path = url.pathname;
+            const method = req.method;
+            // Set CORS headers
+            res.setHeader('Access-Control-Allow-Origin', '*');
+            res.setHeader('Access-Control-Allow-Methods', 'GET, OPTIONS');
+            res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+            res.setHeader('Content-Type', 'application/json');
+            if (method === 'OPTIONS') {
+                res.writeHead(200);
+                res.end();
+                return;
+            }
+            if (method !== 'GET') {
+                this.sendError(res, 405, 'Method not allowed');
+                return;
+            }
+            // Route handling
+            if (path === '/health') {
+                this.handleHealth(res);
+            }
+            else if (path === '/packages') {
+                await this.handlePackages(res);
+            }
+            else if (path.startsWith('/packages/')) {
+                await this.handlePackageRoutes(path, res);
+            }
+            else {
+                this.sendError(res, 404, 'Not found');
+            }
+        }
+        catch (error) {
+            this.logError('Request handling error:', error);
+            this.sendError(res, 500, error.message || 'Internal server error');
+        }
+    }
+    handleHealth(res) {
+        this.sendJson(res, { status: 'ok', service: 'Export Indices MCP Server' });
+    }
+    async handlePackages(res) {
+        const packages = this.packages
+            .filter(unit => unit.isInstanceOf(Unit_TypescriptLib))
+            .map(unit => ({
+            name: unit.config.key,
+            root: unit.config.fullPath
+        }));
+        this.sendJson(res, { packages });
+    }
+    async handlePackageRoutes(path, res) {
+        // Extract package name and remaining path
+        // Path format: /packages/:packageName/...
+        const pathParts = path.split('/').filter(p => p);
+        if (pathParts.length < 2 || pathParts[0] !== 'packages') {
+            this.sendError(res, 404, 'Invalid path');
+            return;
+        }
+        const packageName = decodeURIComponent(pathParts[1]);
+        const packageUnit = this.packages.find(p => p.config.key === packageName);
+        if (!packageUnit || !packageUnit.isInstanceOf(Unit_TypescriptLib)) {
+            this.sendError(res, 404, `Package '${packageName}' not found`);
+            return;
+        }
+        const packageRoot = packageUnit.config.fullPath;
+        const remainingPath = pathParts.slice(2).join('/');
+        if (remainingPath === 'exports') {
+            await this.handleGetAllExports(packageName, packageRoot, res);
+        }
+        else if (remainingPath.startsWith('exports/by-name/')) {
+            const symbolName = decodeURIComponent(remainingPath.replace('exports/by-name/', ''));
+            await this.handleGetByName(packageName, packageRoot, symbolName, res);
+        }
+        else if (remainingPath.startsWith('exports/by-file/')) {
+            const filePath = decodeURIComponent(remainingPath.replace('exports/by-file/', ''));
+            await this.handleGetByFile(packageName, packageRoot, filePath, res);
+        }
+        else if (remainingPath.startsWith('exports/by-type/')) {
+            const symbolType = decodeURIComponent(remainingPath.replace('exports/by-type/', ''));
+            await this.handleGetByType(packageName, packageRoot, symbolType, res);
+        }
+        else if (remainingPath === 'stale') {
+            await this.handleStale(packageName, packageRoot, res);
+        }
+        else {
+            this.sendError(res, 404, 'Not found');
+        }
+    }
+    async handleGetAllExports(packageName, packageRoot, res) {
+        try {
+            const exports = await ExportIndexCache.getAll(this.projectRoot, packageRoot, packageName);
+            this.sendJson(res, { package: packageName, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports');
+            }
+        }
+    }
+    async handleGetByName(packageName, packageRoot, symbolName, res) {
+        try {
+            const symbol = await ExportIndexCache.getByName(this.projectRoot, packageRoot, packageName, symbolName);
+            if (!symbol) {
+                this.sendError(res, 404, `Symbol '${symbolName}' not found in package '${packageName}'`);
+                return;
+            }
+            this.sendJson(res, { package: packageName, symbol });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get symbol');
+            }
+        }
+    }
+    async handleGetByFile(packageName, packageRoot, filePath, res) {
+        try {
+            const exports = await ExportIndexCache.getByFile(this.projectRoot, packageRoot, packageName, filePath);
+            this.sendJson(res, { package: packageName, filePath, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports by file');
+            }
+        }
+    }
+    async handleGetByType(packageName, packageRoot, symbolType, res) {
+        try {
+            const exports = await ExportIndexCache.getByType(this.projectRoot, packageRoot, packageName, symbolType);
+            this.sendJson(res, { package: packageName, symbolType, exports });
+        }
+        catch (error) {
+            if (error.message?.includes('Index file not found')) {
+                this.sendError(res, 404, `Indices not found for package '${packageName}'. Run 'bai --map-exports' to generate indices.`);
+            }
+            else {
+                this.sendError(res, 500, error.message || 'Failed to get exports by type');
+            }
+        }
+    }
+    async handleStale(packageName, packageRoot, res) {
+        try {
+            const stale = await ExportIndexCache.isStale(this.projectRoot, packageRoot, packageName);
+            this.sendJson(res, {
+                package: packageName,
+                stale,
+                message: stale
+                    ? "Source files are newer than index files. Run 'bai --map-exports' to regenerate."
+                    : 'Indices are up to date.'
+            });
+        }
+        catch (error) {
+            this.sendError(res, 500, error.message || 'Failed to check stale status');
+        }
+    }
+    sendJson(res, data) {
+        res.writeHead(200);
+        res.end(JSON.stringify(data, null, 2));
+    }
+    sendError(res, statusCode, message) {
+        res.writeHead(statusCode);
+        res.end(JSON.stringify({ error: message }, null, 2));
+    }
+}

package/exports/types.js

@@ -0,0 +1,3 @@
+// Export types will be defined here if needed
+// Currently using types from ExportMapper.ts
+export {};

package/package.json

@@ -1,24 +1,32 @@
 {
   "name": "@nu-art/build-and-install",
-  "version": "0.401.0",
-  "description": "",
+  "version": "0.401.1",
+  "description": "A build system for monorepos that orchestrates building, testing, and deploying units with dependency-aware phase execution",
   "type": "module",
   "keywords": [
-    "TacB0sS",
-    "infra",
+    "typescript",
+    "build-system",
+    "monorepo",
+    "dependency-management",
+    "phase-execution",
+    "workspace",
+    "units",
+    "automation",
     "nu-art",
-    "commando"
+    "thunderstorm",
+    "build-and-install"
   ],
   "homepage": "https://github.com/nu-art-js/thunderstorm",
   "bugs": {
-    "url": "https://github.com/nu-art-js/thunderstorm/issues"
+    "url": "https://github.com/nu-art-js/thunderstorm/issues?q=is%3Aissue+label%3Abuild-and-install"
   },
   "publishConfig": {
     "directory": "dist"
   },
   "repository": {
     "type": "git",
-    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git"
+    "url": "git+ssh://git@github.com:nu-art-js/thunderstorm.git",
+    "directory": "_thunderstorm/build-and-install"
   },
   "license": "Apache-2.0",
   "author": "TacB0sS",
@@ -31,8 +39,11 @@
   },
   "dependencies": {
     "chokidar": "^3.6.0",
-    "@nu-art/ts-common": "0.401.0",
-    "@nu-art/commando": "0.401.0"
+    "@nu-art/ts-common": "0.401.1",
+    "@nu-art/commando": "0.401.1"
+  },
+  "devDependencies": {
+    "@nu-art/testalot": "0.401.1"
   },
   "unitConfig": {
     "type": "typescript-lib"

package/phases/PhaseManager.d.ts

@@ -0,0 +1,130 @@
+import { Logger } from '@nu-art/ts-common';
+import { RunningStatusHandler } from '../runtime/RunningStatusHandler.js';
+import { Phase } from './definitions/index.js';
+import { BaseUnit } from '../units/index.js';
+/**
+ * Scheduled execution step (before mapping to actual phases/units).
+ */
+export type ScheduledStep = {
+    phases: string[];
+    units: string[];
+};
+/**
+ * Mapped execution step with actual phase and unit instances.
+ */
+export type ExecutionStep = {
+    phases: Phase<any>[];
+    units: BaseUnit<any>[];
+};
+/**
+ * Manages phase execution across units in dependency order.
+ *
+ * **Execution Model**:
+ * - **Phase Groups**: Phases that can run in parallel (e.g., [prepare, compile])
+ * - **Unit Layers**: Units grouped by dependency level (dependencies first)
+ * - **Steps**: Combinations of phase groups × unit layers
+ *
+ * **Execution Flow**:
+ * 1. `calculateExecutionSteps()`: Plans which phases run on which units
+ * 2. `execute()`: Executes steps sequentially, phases in parallel within steps
+ * 3. Units in same layer run phases in parallel (Promise.all)
+ *
+ * **Eligibility Rules**:
+ * - Unit must implement the phase method (e.g., `compile()`, `test()`)
+ * - Unit must be in active/project units (based on phase.unitCategory)
+ * - Phase filter (if present) must pass runtime params
+ *
+ * **Error Handling**:
+ * - First failure stops execution (sets `killed = true`)
+ * - Aggregates all errors into `PhaseAggregatedException`
+ * - Tracks running units for graceful shutdown
+ *
+ * **Resume Support**:
+ * - Skips completed steps (via `runningStatus.startIndex`)
+ * - Skips completed units within steps (via `runningStatus.isCompleted()`)
+ *
+ * **Validation**:
+ * - Constructor validates no duplicate units or phases
+ * - Throws `BadImplementationException` on duplicates
+ */
+export declare class PhaseManager extends Logger {
+    private readonly phases;
+    private readonly units;
+    private runningUnits;
+    private killed;
+    private runningStatus;
+    private activeUnits;
+    private projectUnitKeys;
+    private readonly keyToPhaseMap;
+    constructor(runningStatus: RunningStatusHandler, phases: Phase<any>[][], units: BaseUnit[][], activeUnits: string[], projectUnitKeys: string[]);
+    /**
+     * Calculates the execution plan: which phases run on which units.
+     *
+     * **Algorithm**:
+     * 1. For each phase group (phases that can run together)
+     * 2. Filter phases by runtime params (if phase.filter exists)
+     * 3. For each unit layer (dependency level)
+     * 4. Find units eligible for at least one phase in the group
+     * 5. Group units by which phases they support
+     * 6. Create steps: phase combinations × unit groups
+     *
+     * **Phase Grouping**: Units that support the same set of phases are grouped
+     * together in a step (identified by phase keys joined with '|').
+     *
+     * **Unit Eligibility**:
+     * - Unit must implement phase method
+     * - Unit must be in active/project units (based on phase.unitCategory)
+     *
+     * @returns Array of scheduled steps (phases and unit keys)
+     */
+    calculateExecutionSteps(): Promise<ScheduledStep[]>;
+    /**
+     * Executes the planned steps sequentially.
+     *
+     * **Execution Model**:
+     * - Steps run sequentially (one after another)
+     * - Units within a step run phases in parallel (Promise.all)
+     * - Phases for a unit run sequentially (in phase group order)
+     *
+     * **Resume Support**:
+     * - Starts from `runningStatus.startIndex` (if --continue)
+     * - Skips units marked as completed
+     *
+     * **Dry Run**: If `--dry-run`, only logs phase/unit names without executing.
+     *
+     * **Error Handling**:
+     * - First error stops execution (sets `killed = true`)
+     * - All errors aggregated into `PhaseAggregatedException`
+     * - Running units tracked for graceful shutdown
+     *
+     * **Performance**: Logs operation duration if > 1.5 seconds.
+     *
+     * @param _steps - Scheduled steps to execute
+     * @throws PhaseAggregatedException if any phase fails
+     */
+    execute(_steps: ScheduledStep[]): Promise<void>;
+    /**
+     * Gracefully stops execution and kills all running units.
+     *
+     * Called on SIGINT (Ctrl+C). Sets `killed = true` to stop further execution,
+     * then calls `kill()` on all currently running units.
+     *
+     * @returns Promise that resolves when all units are killed
+     */
+    break(): Promise<void[]>;
+    /**
+     * Maps scheduled step (with string keys) to execution step (with actual instances).
+     *
+     * **Mapping Process**:
+     * - Maps phase keys to Phase instances using `keyToPhaseMap`
+     * - Maps unit keys to BaseUnit instances by searching through unit layers
+     *
+     * **Performance Note**: Unit lookup iterates through all layers (O(n) complexity).
+     * Consider using a lookup map for O(1) access in large workspaces.
+     *
+     * @param scheduledStep - Scheduled step with phase/unit keys
+     * @returns Execution step with phase/unit instances
+     * @throws Error if phase or unit not found
+     */
+    private mapStep;
+}

package/{v3 → phases}/PhaseManager.js

@@ -1,6 +1,37 @@
 import { addItemToArray, BadImplementationException, exists, flatArray, Logger, removeItemFromArray, timeCounter } from '@nu-art/ts-common';
-import { PhaseAggregatedException } from '../core/exceptions/PhaseAggregatedException.js';
-import { UnitPhaseException } from '../core/exceptions/UnitPhaseException.js';
+import { PhaseAggregatedException } from '../exceptions/PhaseAggregatedException.js';
+import { UnitPhaseException } from '../exceptions/UnitPhaseException.js';
+/**
+ * Manages phase execution across units in dependency order.
+ *
+ * **Execution Model**:
+ * - **Phase Groups**: Phases that can run in parallel (e.g., [prepare, compile])
+ * - **Unit Layers**: Units grouped by dependency level (dependencies first)
+ * - **Steps**: Combinations of phase groups × unit layers
+ *
+ * **Execution Flow**:
+ * 1. `calculateExecutionSteps()`: Plans which phases run on which units
+ * 2. `execute()`: Executes steps sequentially, phases in parallel within steps
+ * 3. Units in same layer run phases in parallel (Promise.all)
+ *
+ * **Eligibility Rules**:
+ * - Unit must implement the phase method (e.g., `compile()`, `test()`)
+ * - Unit must be in active/project units (based on phase.unitCategory)
+ * - Phase filter (if present) must pass runtime params
+ *
+ * **Error Handling**:
+ * - First failure stops execution (sets `killed = true`)
+ * - Aggregates all errors into `PhaseAggregatedException`
+ * - Tracks running units for graceful shutdown
+ *
+ * **Resume Support**:
+ * - Skips completed steps (via `runningStatus.startIndex`)
+ * - Skips completed units within steps (via `runningStatus.isCompleted()`)
+ *
+ * **Validation**:
+ * - Constructor validates no duplicate units or phases
+ * - Throws `BadImplementationException` on duplicates
+ */
 export class PhaseManager extends Logger {
     phases;
     units;
@@ -36,6 +67,26 @@ export class PhaseManager extends Logger {
         }, {});
     }
     //######################### Initialization #########################
+    /**
+     * Calculates the execution plan: which phases run on which units.
+     *
+     * **Algorithm**:
+     * 1. For each phase group (phases that can run together)
+     * 2. Filter phases by runtime params (if phase.filter exists)
+     * 3. For each unit layer (dependency level)
+     * 4. Find units eligible for at least one phase in the group
+     * 5. Group units by which phases they support
+     * 6. Create steps: phase combinations × unit groups
+     *
+     * **Phase Grouping**: Units that support the same set of phases are grouped
+     * together in a step (identified by phase keys joined with '|').
+     *
+     * **Unit Eligibility**:
+     * - Unit must implement phase method
+     * - Unit must be in active/project units (based on phase.unitCategory)
+     *
+     * @returns Array of scheduled steps (phases and unit keys)
+     */
     async calculateExecutionSteps() {
         const steps = [];
         this.logDebug('Calculating execution steps for phases: ', this.phases.map(phases => phases.map(phase => phase.key)));
@@ -87,6 +138,30 @@ export class PhaseManager extends Logger {
         this.logVerbose('Calculated execution steps: ', steps);
         return steps;
     }
+    /**
+     * Executes the planned steps sequentially.
+     *
+     * **Execution Model**:
+     * - Steps run sequentially (one after another)
+     * - Units within a step run phases in parallel (Promise.all)
+     * - Phases for a unit run sequentially (in phase group order)
+     *
+     * **Resume Support**:
+     * - Starts from `runningStatus.startIndex` (if --continue)
+     * - Skips units marked as completed
+     *
+     * **Dry Run**: If `--dry-run`, only logs phase/unit names without executing.
+     *
+     * **Error Handling**:
+     * - First error stops execution (sets `killed = true`)
+     * - All errors aggregated into `PhaseAggregatedException`
+     * - Running units tracked for graceful shutdown
+     *
+     * **Performance**: Logs operation duration if > 1.5 seconds.
+     *
+     * @param _steps - Scheduled steps to execute
+     * @throws PhaseAggregatedException if any phase fails
+     */
     async execute(_steps) {
         this.runningUnits = [];
         for (let i = this.runningStatus.startIndex; i < _steps.length; i++) {
@@ -143,10 +218,32 @@ export class PhaseManager extends Logger {
         }
         this.logInfo('All steps completed.');
     }
+    /**
+     * Gracefully stops execution and kills all running units.
+     *
+     * Called on SIGINT (Ctrl+C). Sets `killed = true` to stop further execution,
+     * then calls `kill()` on all currently running units.
+     *
+     * @returns Promise that resolves when all units are killed
+     */
     break() {
         this.killed = true;
         return Promise.all(this.runningUnits.map(unit => unit.kill()));
     }
+    /**
+     * Maps scheduled step (with string keys) to execution step (with actual instances).
+     *
+     * **Mapping Process**:
+     * - Maps phase keys to Phase instances using `keyToPhaseMap`
+     * - Maps unit keys to BaseUnit instances by searching through unit layers
+     *
+     * **Performance Note**: Unit lookup iterates through all layers (O(n) complexity).
+     * Consider using a lookup map for O(1) access in large workspaces.
+     *
+     * @param scheduledStep - Scheduled step with phase/unit keys
+     * @returns Execution step with phase/unit instances
+     * @throws Error if phase or unit not found
+     */
     mapStep(scheduledStep) {
         const mappedPhases = scheduledStep.phases.map(phaseKey => {
             const phase = this.keyToPhaseMap[phaseKey];

package/{v3/phase → phases/definitions}/consts.d.ts

@@ -1,3 +1,24 @@
+/**
+ * Phase definitions for the build system.
+ *
+ * **Phase Groups**:
+ * - `phases_Terminating`: Phases that terminate execution after completion
+ * - `phases_Build`: Main build phases (purge, prepare, install, compile, test, etc.)
+ * - `phases_Launch`: Launch phases (start applications)
+ * - `phases_Deploy`: Deployment phases
+ *
+ * **Phase Execution Order**:
+ * 1. Build phases run first (prepare, install, compile, test)
+ * 2. Terminating phases can stop execution early
+ * 3. Launch phases start applications
+ * 4. Deploy phases publish/deploy
+ *
+ * **Phase Filters**: Most phases have filters based on runtime params (e.g., `--lint`, `--test`).
+ * Phases only run if their filter returns true (or no filter is present).
+ *
+ * **Dependency Phases**: Some phases depend on others (e.g., `compile` depends on `preCompile`).
+ * Dependencies are automatically resolved by PhaseManager.
+ */
 import { Phase } from './types.js';
 export type Phase_PrintDependencyTree = typeof phase_PrintDependencyTree;
 export declare const phaseKey_PrintDependencyTree = "print-dependency-tree";
@@ -24,6 +45,12 @@ export declare const phase_Lint: Phase<'lint'>;
 export type Phase_PreCompile = typeof phase_PreCompile;
 export declare const phaseKey_PreCompile = "preCompile";
 export declare const phase_PreCompile: Phase<'preCompile'>;
+export type Phase_ExtractDynamicDeps = typeof phase_ExtractDynamicDeps;
+export declare const phaseKey_ExtractDynamicDeps = "extract-dynamic-deps";
+export declare const phase_ExtractDynamicDeps: Phase<'extractDynamicDeps'>;
+export type Phase_MapExports = typeof phase_MapExports;
+export declare const phaseKey_MapExports = "map-exports";
+export declare const phase_MapExports: Phase<'mapExports'>;
 export type Phase_Compile = typeof phase_Compile;
 export declare const phaseKey_Compile = "compile";
 export declare const phase_Compile: Phase<'compile'>;
@@ -40,6 +67,9 @@ export declare const phases_Build: Phase<string>[][];
 export type Phase_Launch = typeof phase_Launch;
 export declare const phaseKey_Launch = "launch";
 export declare const phase_Launch: Phase<'launch'>;
+export type Phase_IndicesMcpServer = typeof phase_IndicesMcpServer;
+export declare const phaseKey_IndicesMcpServer = "indices-mcp-server";
+export declare const phase_IndicesMcpServer: Phase<'indicesMcpServer'>;
 export declare const phases_Launch: Phase<string>[][];
 export type Phase_Publish = typeof phase_Publish;
 export declare const phaseKey_Publish = "publish";
@@ -50,4 +80,10 @@ export declare const phase_PostPublish: Phase<'postPublish'>;
 export type Phase_Deploy = typeof phase_Deploy;
 export declare const phaseKey_Deploy = "deploy";
 export declare const phase_Deploy: Phase<'deploy'>;
+export type Phase_BuildPushImage = typeof phase_BuildPushImage;
+export declare const phaseKey_BuildPushImage = "build-push-image";
+export declare const phase_BuildPushImage: Phase<'buildPushImage'>;
+export type Phase_DeployImage = typeof phase_DeployImage;
+export declare const phaseKey_DeployImage = "deploy-image";
+export declare const phase_DeployImage: Phase<'deployImage'>;
 export declare const phases_Deploy: Phase<string>[][];