typekro 0.1.0

package/dist/core/deployment/engine.js

@@ -0,0 +1,1408 @@
+/**
+ * Direct Deployment Engine
+ *
+ * Orchestrates the deployment of Kubernetes resources directly to a cluster
+ * without requiring the Kro controller, using in-process dependency resolution.
+ */
+import * as k8s from '@kubernetes/client-node';
+import { DependencyResolver } from '../dependencies/index.js';
+import { CircularDependencyError } from '../errors.js';
+import { getComponentLogger } from '../logging/index.js';
+import { ReferenceResolver, DeploymentMode } from '../references/index.js';
+import { ResourceDeploymentError } from '../types/deployment.js';
+import { ResourceReadinessChecker } from './readiness.js';
+import { StatusHydrator } from './status-hydrator.js';
+import { ensureReadinessEvaluator } from '../../utils/helpers.js';
+export class DirectDeploymentEngine {
+    kubeClient;
+    deploymentMode;
+    dependencyResolver;
+    referenceResolver;
+    k8sApi;
+    readinessChecker;
+    statusHydrator;
+    deploymentState = new Map();
+    readyResources = new Set(); // Track resources that are already ready
+    logger = getComponentLogger('deployment-engine');
+    constructor(kubeClient, k8sApi, referenceResolver, deploymentMode = DeploymentMode.DIRECT) {
+        this.kubeClient = kubeClient;
+        this.deploymentMode = deploymentMode;
+        this.dependencyResolver = new DependencyResolver();
+        this.referenceResolver = referenceResolver || new ReferenceResolver(kubeClient, this.deploymentMode, k8sApi);
+        this.k8sApi = k8sApi || kubeClient.makeApiClient(k8s.KubernetesObjectApi);
+        this.readinessChecker = new ResourceReadinessChecker(this.k8sApi);
+        this.statusHydrator = new StatusHydrator(this.k8sApi);
+        // Set up callback to track ready resources
+        this.readinessChecker.setOnResourceReady((resource) => {
+            const resourceKey = `${resource.kind}/${resource.name}/${resource.namespace}`;
+            this.readyResources.add(resourceKey);
+            this.logger.debug('Resource marked as ready via generic readiness checker', {
+                resourceKey,
+                totalReady: this.readyResources.size
+            });
+        });
+    }
+    /**
+     * Get the Kubernetes API client for external integrations
+     * @returns The configured KubernetesObjectApi instance
+     */
+    getKubernetesApi() {
+        return this.k8sApi;
+    }
+    /**
+     * Check if a deployed resource is ready using the factory-provided readiness evaluator
+     */
+    async isDeployedResourceReady(deployedResource) {
+        try {
+            // Check if the deployed resource has a factory-provided readiness evaluator
+            const readinessEvaluator = deployedResource.manifest.readinessEvaluator;
+            if (readinessEvaluator) {
+                // Use the factory-provided readiness evaluator
+                // Create a resource reference for the API call
+                const resourceRef = {
+                    apiVersion: deployedResource.manifest.apiVersion || '',
+                    kind: deployedResource.kind,
+                    metadata: {
+                        name: deployedResource.name,
+                        namespace: deployedResource.namespace,
+                    },
+                };
+                // Get the live resource from the cluster
+                const liveResource = await this.k8sApi.read(resourceRef);
+                // Use the factory-provided readiness evaluator
+                const result = readinessEvaluator(liveResource.body);
+                if (typeof result === 'boolean') {
+                    return result;
+                }
+                else if (result && typeof result === 'object' && 'ready' in result) {
+                    return result.ready;
+                }
+                else {
+                    this.logger.warn('Readiness evaluator returned unexpected result', {
+                        resourceId: deployedResource.id,
+                        result
+                    });
+                    return false;
+                }
+            }
+            else {
+                // Fallback to generic readiness checker
+                const resourceRef = {
+                    apiVersion: deployedResource.manifest.apiVersion || '',
+                    kind: deployedResource.kind,
+                    metadata: {
+                        name: deployedResource.name,
+                        namespace: deployedResource.namespace,
+                    },
+                };
+                const liveResource = await this.k8sApi.read(resourceRef);
+                return this.readinessChecker.isResourceReady(liveResource.body);
+            }
+        }
+        catch (error) {
+            this.logger.debug('Failed to check resource readiness', {
+                error: error,
+                resourceId: deployedResource.id,
+                kind: deployedResource.kind,
+                name: deployedResource.name,
+                namespace: deployedResource.namespace
+            });
+            return false;
+        }
+    }
+    /**
+     * Get all deployment states for health checking
+     */
+    getAllDeploymentStates() {
+        return Array.from(this.deploymentState.values());
+    }
+    /**
+     * Deploy a resource graph to the Kubernetes cluster
+     */
+    async deploy(graph, options) {
+        const deploymentId = this.generateDeploymentId();
+        const startTime = Date.now();
+        const deployedResources = [];
+        const errors = [];
+        const deploymentLogger = this.logger.child({ deploymentId, resourceCount: graph.resources.length });
+        deploymentLogger.info('Starting deployment', { options });
+        try {
+            this.emitEvent(options, {
+                type: 'started',
+                message: `Starting deployment of ${graph.resources.length} resources`,
+                timestamp: new Date(),
+            });
+            // 1. Validate no cycles in dependency graph
+            deploymentLogger.debug('Validating dependency graph', { dependencyGraph: graph.dependencyGraph });
+            this.dependencyResolver.validateNoCycles(graph.dependencyGraph);
+            // 2. Analyze deployment order and identify parallel stages
+            deploymentLogger.debug('Analyzing deployment order for parallel execution');
+            const deploymentPlan = this.dependencyResolver.analyzeDeploymentOrder(graph.dependencyGraph);
+            deploymentLogger.debug('Deployment plan determined', {
+                levels: deploymentPlan.levels.length,
+                totalResources: deploymentPlan.totalResources,
+                maxParallelism: deploymentPlan.maxParallelism
+            });
+            // 3. Create resolution context
+            const context = {
+                deployedResources,
+                kubeClient: this.kubeClient,
+                ...(options.namespace && { namespace: options.namespace }),
+                timeout: options.timeout || 30000,
+            };
+            // 4. Deploy resources in parallel stages
+            for (let levelIndex = 0; levelIndex < deploymentPlan.levels.length; levelIndex++) {
+                const currentLevel = deploymentPlan.levels[levelIndex];
+                if (!currentLevel) {
+                    continue;
+                }
+                const levelLogger = deploymentLogger.child({
+                    level: levelIndex + 1,
+                    resourceCount: currentLevel.length
+                });
+                levelLogger.debug(`Deploying level ${levelIndex + 1} with ${currentLevel.length} resources in parallel`);
+                // Track performance metrics for this level
+                const levelStartTime = Date.now();
+                // Deploy all resources in this level in parallel
+                const levelPromises = currentLevel.map(async (resourceId) => {
+                    const resourceLogger = deploymentLogger.child({ resourceId });
+                    resourceLogger.debug('Starting resource deployment');
+                    const resource = graph.resources.find((r) => r.id === resourceId);
+                    if (!resource) {
+                        resourceLogger.error('Resource not found in graph');
+                        const error = new Error(`Resource with id '${resourceId}' not found in graph`);
+                        return {
+                            success: false,
+                            resourceId,
+                            error: {
+                                resourceId,
+                                phase: 'validation',
+                                error,
+                                timestamp: new Date(),
+                            }
+                        };
+                    }
+                    resourceLogger.debug('Found resource in graph', {
+                        resourceId: resource.id,
+                        kind: resource.manifest?.kind,
+                        name: resource.manifest?.metadata?.name
+                    });
+                    try {
+                        resourceLogger.debug('Calling deploySingleResource');
+                        // Wait for CRD establishment if this is a custom resource
+                        await this.waitForCRDIfCustomResource(resource.manifest, options, resourceLogger);
+                        // FIX: Unconditionally ensure the readiness evaluator is attached just before deployment.
+                        const resourceWithEvaluator = ensureReadinessEvaluator(resource.manifest);
+                        const deployedResource = await this.deploySingleResource(resourceWithEvaluator, context, options);
+                        resourceLogger.debug('Resource deployed successfully');
+                        return {
+                            success: true,
+                            resourceId,
+                            deployedResource
+                        };
+                    }
+                    catch (error) {
+                        resourceLogger.error('Resource deployment failed', error);
+                        const failedResource = {
+                            id: resourceId,
+                            kind: resource.manifest.kind,
+                            name: resource.manifest.metadata?.name || 'unknown',
+                            namespace: resource.manifest.metadata?.namespace || 'default',
+                            manifest: resource.manifest,
+                            status: 'failed',
+                            deployedAt: new Date(),
+                            error: error,
+                        };
+                        return {
+                            success: false,
+                            resourceId,
+                            deployedResource: failedResource,
+                            error: {
+                                resourceId,
+                                phase: 'deployment',
+                                error: error,
+                                timestamp: new Date(),
+                            }
+                        };
+                    }
+                });
+                // Wait for all resources in this level to complete
+                const levelResults = await Promise.allSettled(levelPromises);
+                // Process results and handle errors
+                let levelHasFailures = false;
+                for (const result of levelResults) {
+                    if (result.status === 'fulfilled') {
+                        const deploymentResult = result.value;
+                        if (deploymentResult.success && deploymentResult.deployedResource) {
+                            deployedResources.push(deploymentResult.deployedResource);
+                        }
+                        else {
+                            levelHasFailures = true;
+                            if (deploymentResult.error) {
+                                errors.push(deploymentResult.error);
+                            }
+                            if (deploymentResult.deployedResource) {
+                                deployedResources.push(deploymentResult.deployedResource);
+                            }
+                        }
+                    }
+                    else {
+                        // Promise was rejected
+                        levelHasFailures = true;
+                        levelLogger.error('Unexpected promise rejection in parallel deployment', result.reason);
+                    }
+                }
+                // Handle rollback if there are failures and rollback is enabled
+                if (levelHasFailures && options.rollbackOnFailure) {
+                    levelLogger.warn('Level deployment failed, initiating rollback');
+                    await this.rollbackDeployedResources(deployedResources, options);
+                    const duration = Date.now() - startTime;
+                    this.emitEvent(options, {
+                        type: 'rollback',
+                        message: `Deployment failed and rolled back in ${duration}ms`,
+                        timestamp: new Date(),
+                    });
+                    return {
+                        deploymentId,
+                        resources: deployedResources,
+                        dependencyGraph: graph.dependencyGraph,
+                        duration,
+                        status: 'failed',
+                        errors,
+                    };
+                }
+                // Calculate level performance metrics
+                const levelDuration = Date.now() - levelStartTime;
+                const successfulCount = levelResults.filter(r => r.status === 'fulfilled' && r.value.success).length;
+                const failedCount = levelResults.filter(r => r.status === 'rejected' || (r.status === 'fulfilled' && !r.value.success)).length;
+                const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+                // Use debug level in test environments to reduce noise, info level in production
+                const logLevel = isTestEnvironment ? 'debug' : 'info';
+                levelLogger[logLevel](`Level ${levelIndex + 1} deployment completed`, {
+                    successful: successfulCount,
+                    failed: failedCount,
+                    duration: levelDuration,
+                    parallelism: currentLevel.length,
+                    averageTimePerResource: Math.round(levelDuration / currentLevel.length)
+                });
+            }
+            const duration = Date.now() - startTime;
+            const successfulResources = deployedResources.filter((r) => r.status !== 'failed');
+            const status = errors.length === 0 ? 'success' : successfulResources.length > 0 ? 'partial' : 'failed';
+            // Log comprehensive performance metrics
+            const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+            // Use debug level in test environments to reduce noise, info level in production
+            const logLevel = isTestEnvironment ? 'debug' : 'info';
+            deploymentLogger[logLevel]('Parallel deployment performance metrics', {
+                totalDuration: duration,
+                totalResources: deploymentPlan.totalResources,
+                parallelLevels: deploymentPlan.levels.length,
+                maxParallelism: deploymentPlan.maxParallelism,
+                averageTimePerResource: Math.round(duration / deploymentPlan.totalResources),
+                successfulResources: successfulResources.length,
+                failedResources: errors.length,
+                parallelismEfficiency: Math.round((deploymentPlan.totalResources / deploymentPlan.levels.length) / deploymentPlan.maxParallelism * 100),
+                status
+            });
+            this.emitEvent(options, {
+                type: status === 'success' ? 'completed' : 'failed',
+                message: `Deployment ${status} in ${duration}ms (${deploymentPlan.levels.length} parallel levels, max ${deploymentPlan.maxParallelism} concurrent)`,
+                timestamp: new Date(),
+            });
+            // Store deployment state for rollback
+            this.deploymentState.set(deploymentId, {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                startTime: new Date(startTime),
+                endTime: new Date(),
+                status: status === 'success' ? 'completed' : status === 'partial' ? 'completed' : 'failed',
+                options,
+            });
+            return {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                duration,
+                status,
+                errors,
+            };
+        }
+        catch (error) {
+            // Re-throw circular dependency errors immediately - these are configuration errors
+            if (error instanceof CircularDependencyError) {
+                throw error;
+            }
+            const duration = Date.now() - startTime;
+            this.emitEvent(options, {
+                type: 'failed',
+                message: `Deployment failed: ${error}`,
+                timestamp: new Date(),
+                error: error,
+            });
+            // Store deployment state even for failed deployments (for rollback)
+            this.deploymentState.set(deploymentId, {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                startTime: new Date(startTime),
+                endTime: new Date(),
+                status: 'failed',
+                options,
+            });
+            return {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                duration,
+                status: 'failed',
+                errors: [
+                    {
+                        resourceId: 'deployment',
+                        phase: 'deployment',
+                        error: error,
+                        timestamp: new Date(),
+                    },
+                ],
+            };
+        }
+    }
+    /**
+     * Analyze closure dependencies to determine execution levels
+     */
+    analyzeClosureDependencies(closures, spec, dependencyGraph) {
+        const closureDependencies = [];
+        for (const [name, closure] of Object.entries(closures)) {
+            // For now, analyze dependencies by examining the closure's configuration
+            // This is a simplified implementation - in practice, we would need to analyze
+            // the closure's arguments to detect resource references
+            const dependencies = this.extractClosureDependencies(closure, spec);
+            // Determine execution level based on dependencies
+            // For now, assign all closures to level -1 to ensure they run before all resources
+            // This is especially important for closures that install CRDs (like fluxSystem)
+            let level = -1;
+            if (dependencies.length > 0) {
+                // Find the maximum level of any dependency + 1
+                for (const depId of dependencies) {
+                    const depLevel = this.getResourceLevel(depId, dependencyGraph);
+                    level = Math.max(level, depLevel + 1);
+                }
+            }
+            closureDependencies.push({
+                name,
+                closure,
+                dependencies,
+                level,
+            });
+        }
+        return closureDependencies;
+    }
+    /**
+     * Extract dependencies from a closure by analyzing its configuration
+     * This is a simplified implementation - in practice, we would need more sophisticated analysis
+     */
+    extractClosureDependencies(closure, spec) {
+        // For now, return empty dependencies since closures typically don't depend on Enhanced<> resources
+        // In the future, this could analyze closure arguments for resource references
+        return [];
+    }
+    /**
+     * Get the execution level of a resource in the dependency graph
+     */
+    getResourceLevel(resourceId, dependencyGraph) {
+        // Find the level where this resource appears in the deployment plan
+        const deploymentPlan = this.dependencyResolver.analyzeDeploymentOrder(dependencyGraph);
+        for (let levelIndex = 0; levelIndex < deploymentPlan.levels.length; levelIndex++) {
+            const level = deploymentPlan.levels[levelIndex];
+            if (level && level.includes(resourceId)) {
+                return levelIndex;
+            }
+        }
+        return 0; // Default to level 0 if not found
+    }
+    /**
+     * Integrate closures into the deployment plan based on their dependencies
+     */
+    integrateClosuresIntoPlan(deploymentPlan, closureDependencies) {
+        // Create enhanced levels with both resources and closures
+        const enhancedLevels = [];
+        // Check if we have any closures at level -1 (pre-resource level)
+        const preResourceClosures = closureDependencies.filter(c => c.level === -1);
+        // If we have pre-resource closures, add them as level 0 and shift everything else
+        if (preResourceClosures.length > 0) {
+            enhancedLevels.push({
+                resources: [],
+                closures: preResourceClosures,
+            });
+        }
+        // Initialize levels with existing resources (shifted if we added a pre-resource level)
+        for (let i = 0; i < deploymentPlan.levels.length; i++) {
+            enhancedLevels.push({
+                resources: deploymentPlan.levels[i] || [],
+                closures: [],
+            });
+        }
+        // Add closures to their appropriate levels (excluding level -1 which we already handled)
+        for (const closureInfo of closureDependencies) {
+            if (closureInfo.level === -1) {
+                continue; // Already handled above
+            }
+            // Adjust level index if we added a pre-resource level
+            const adjustedLevel = preResourceClosures.length > 0 ? closureInfo.level + 1 : closureInfo.level;
+            // Ensure we have enough levels
+            while (enhancedLevels.length <= adjustedLevel) {
+                enhancedLevels.push({ resources: [], closures: [] });
+            }
+            const targetLevel = enhancedLevels[adjustedLevel];
+            if (targetLevel) {
+                targetLevel.closures.push(closureInfo);
+            }
+        }
+        return {
+            levels: enhancedLevels,
+            totalResources: deploymentPlan.totalResources,
+            totalClosures: closureDependencies.length,
+            maxParallelism: Math.max(deploymentPlan.maxParallelism, Math.max(...enhancedLevels.map(level => level.closures.length))),
+        };
+    }
+    /**
+     * Deploy a resource graph with deployment closures integrated into level-based execution
+     */
+    async deployWithClosures(graph, closures, options, spec, alchemyScope) {
+        const deploymentId = this.generateDeploymentId();
+        const startTime = Date.now();
+        const deployedResources = [];
+        const errors = [];
+        const deploymentLogger = this.logger.child({
+            deploymentId,
+            resourceCount: graph.resources.length,
+            closureCount: Object.keys(closures).length
+        });
+        deploymentLogger.info('Starting deployment with closures', {
+            options,
+            closures: Object.keys(closures)
+        });
+        try {
+            this.emitEvent(options, {
+                type: 'started',
+                message: `Starting deployment of ${graph.resources.length} resources and ${Object.keys(closures).length} closures`,
+                timestamp: new Date(),
+            });
+            // 1. Validate no cycles in dependency graph
+            deploymentLogger.debug('Validating dependency graph', { dependencyGraph: graph.dependencyGraph });
+            this.dependencyResolver.validateNoCycles(graph.dependencyGraph);
+            // 2. Analyze deployment order and identify parallel stages
+            deploymentLogger.debug('Analyzing deployment order for parallel execution');
+            const deploymentPlan = this.dependencyResolver.analyzeDeploymentOrder(graph.dependencyGraph);
+            deploymentLogger.debug('Deployment plan determined', {
+                levels: deploymentPlan.levels.length,
+                totalResources: deploymentPlan.totalResources,
+                maxParallelism: deploymentPlan.maxParallelism
+            });
+            // 3. Analyze closure dependencies and integrate into deployment plan
+            const closureDependencies = this.analyzeClosureDependencies(closures, spec, graph.dependencyGraph);
+            const enhancedPlan = this.integrateClosuresIntoPlan(deploymentPlan, closureDependencies);
+            deploymentLogger.debug('Enhanced deployment plan with closures', {
+                levels: enhancedPlan.levels.length,
+                totalResources: enhancedPlan.totalResources,
+                totalClosures: enhancedPlan.totalClosures,
+                maxParallelism: enhancedPlan.maxParallelism
+            });
+            // 4. Create resolution context
+            const context = {
+                deployedResources,
+                kubeClient: this.kubeClient,
+                ...(options.namespace && { namespace: options.namespace }),
+                timeout: options.timeout || 30000,
+            };
+            // 5. Deploy resources and closures level by level with proper dependency handling
+            for (let levelIndex = 0; levelIndex < enhancedPlan.levels.length; levelIndex++) {
+                const currentLevel = enhancedPlan.levels[levelIndex];
+                if (!currentLevel) {
+                    continue;
+                }
+                const levelLogger = deploymentLogger.child({
+                    level: levelIndex + 1,
+                    resourceCount: currentLevel.resources.length,
+                    closureCount: currentLevel.closures.length
+                });
+                levelLogger.debug(`Deploying level ${levelIndex + 1} with ${currentLevel.resources.length} resources and ${currentLevel.closures.length} closures in parallel`);
+                const levelStartTime = Date.now();
+                // Create deployment context for closures at this level
+                const deployedResourcesMap = new Map();
+                // Populate with resources from previous levels
+                for (const resource of deployedResources) {
+                    deployedResourcesMap.set(resource.id, resource);
+                }
+                const deploymentContext = {
+                    kubernetesApi: this.k8sApi,
+                    ...(alchemyScope && { alchemyScope }),
+                    ...(options.namespace && { namespace: options.namespace }),
+                    deployedResources: deployedResourcesMap,
+                    resolveReference: async (ref) => {
+                        // Enhanced reference resolution - will be improved in future tasks
+                        return ref;
+                    },
+                };
+                // Prepare promises for both resources and closures
+                const levelPromises = [];
+                // Add resource deployment promises
+                const resourcePromises = currentLevel.resources.map(async (resourceId) => {
+                    const resourceLogger = deploymentLogger.child({ resourceId });
+                    resourceLogger.debug('Starting resource deployment');
+                    const resource = graph.resources.find((r) => r.id === resourceId);
+                    if (!resource) {
+                        resourceLogger.error('Resource not found in graph');
+                        const error = new Error(`Resource with id '${resourceId}' not found in graph`);
+                        return {
+                            success: false,
+                            resourceId,
+                            error: {
+                                resourceId,
+                                phase: 'validation',
+                                error,
+                                timestamp: new Date(),
+                            }
+                        };
+                    }
+                    resourceLogger.debug('Found resource in graph', {
+                        resourceId: resource.id,
+                        kind: resource.manifest?.kind,
+                        name: resource.manifest?.metadata?.name
+                    });
+                    try {
+                        resourceLogger.debug('Calling deploySingleResource');
+                        const resourceWithEvaluator = ensureReadinessEvaluator(resource.manifest);
+                        const deployedResource = await this.deploySingleResource(resourceWithEvaluator, context, options);
+                        resourceLogger.debug('Resource deployed successfully');
+                        return {
+                            success: true,
+                            resourceId,
+                            deployedResource
+                        };
+                    }
+                    catch (error) {
+                        resourceLogger.error('Resource deployment failed', error);
+                        const failedResource = {
+                            id: resourceId,
+                            kind: resource.manifest.kind,
+                            name: resource.manifest.metadata?.name || 'unknown',
+                            namespace: resource.manifest.metadata?.namespace || 'default',
+                            manifest: resource.manifest,
+                            status: 'failed',
+                            deployedAt: new Date(),
+                            error: error,
+                        };
+                        return {
+                            success: false,
+                            resourceId,
+                            deployedResource: failedResource,
+                            error: {
+                                resourceId,
+                                phase: 'deployment',
+                                error: error,
+                                timestamp: new Date(),
+                            }
+                        };
+                    }
+                });
+                // Add closure execution promises
+                const closurePromises = currentLevel.closures.map(async (closureInfo) => {
+                    const closureLogger = levelLogger.child({ closureName: closureInfo.name });
+                    closureLogger.debug('Executing closure at level', { level: levelIndex + 1 });
+                    try {
+                        const result = await closureInfo.closure(deploymentContext);
+                        closureLogger.debug('Closure executed successfully', { resultCount: result?.length || 0 });
+                        return {
+                            success: true,
+                            type: 'closure',
+                            name: closureInfo.name,
+                            result
+                        };
+                    }
+                    catch (error) {
+                        closureLogger.error('Closure execution failed', error);
+                        return {
+                            success: false,
+                            type: 'closure',
+                            name: closureInfo.name,
+                            error: {
+                                resourceId: `closure-${closureInfo.name}`,
+                                phase: 'deployment',
+                                error: error,
+                                timestamp: new Date(),
+                            }
+                        };
+                    }
+                });
+                // Combine all promises for this level
+                levelPromises.push(...resourcePromises, ...closurePromises);
+                // Wait for all resources and closures in this level to complete
+                const levelResults = await Promise.allSettled(levelPromises);
+                // Process results and handle errors
+                let levelHasFailures = false;
+                let successfulResources = 0;
+                let successfulClosures = 0;
+                let failedResources = 0;
+                let failedClosures = 0;
+                for (const result of levelResults) {
+                    if (result.status === 'fulfilled') {
+                        const deploymentResult = result.value;
+                        if (deploymentResult.type === 'closure') {
+                            // Handle closure result
+                            if (deploymentResult.success) {
+                                successfulClosures++;
+                            }
+                            else {
+                                levelHasFailures = true;
+                                failedClosures++;
+                                if (deploymentResult.error) {
+                                    errors.push(deploymentResult.error);
+                                }
+                            }
+                        }
+                        else {
+                            // Handle resource result
+                            if (deploymentResult.success && deploymentResult.deployedResource) {
+                                deployedResources.push(deploymentResult.deployedResource);
+                                successfulResources++;
+                            }
+                            else {
+                                levelHasFailures = true;
+                                failedResources++;
+                                if (deploymentResult.error) {
+                                    errors.push(deploymentResult.error);
+                                }
+                                if (deploymentResult.deployedResource) {
+                                    deployedResources.push(deploymentResult.deployedResource);
+                                }
+                            }
+                        }
+                    }
+                    else {
+                        levelHasFailures = true;
+                        levelLogger.error('Unexpected promise rejection in parallel deployment', result.reason);
+                    }
+                }
+                // Handle rollback if there are failures and rollback is enabled
+                if (levelHasFailures && options.rollbackOnFailure) {
+                    levelLogger.warn('Level deployment failed, initiating rollback');
+                    await this.rollbackDeployedResources(deployedResources, options);
+                    const duration = Date.now() - startTime;
+                    this.emitEvent(options, {
+                        type: 'rollback',
+                        message: `Deployment failed and rolled back in ${duration}ms`,
+                        timestamp: new Date(),
+                    });
+                    return {
+                        deploymentId,
+                        resources: deployedResources,
+                        dependencyGraph: graph.dependencyGraph,
+                        duration,
+                        status: 'failed',
+                        errors,
+                    };
+                }
+                // Calculate level performance metrics
+                const levelDuration = Date.now() - levelStartTime;
+                const totalOperations = currentLevel.resources.length + currentLevel.closures.length;
+                const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+                const logLevel = isTestEnvironment ? 'debug' : 'info';
+                levelLogger[logLevel](`Level ${levelIndex + 1} deployment completed`, {
+                    resources: { successful: successfulResources, failed: failedResources },
+                    closures: { successful: successfulClosures, failed: failedClosures },
+                    duration: levelDuration,
+                    parallelism: totalOperations,
+                    averageTimePerOperation: totalOperations > 0 ? Math.round(levelDuration / totalOperations) : 0
+                });
+            }
+            const duration = Date.now() - startTime;
+            const successfulResources = deployedResources.filter((r) => r.status !== 'failed');
+            const status = errors.length === 0 ? 'success' : successfulResources.length > 0 ? 'partial' : 'failed';
+            // Log comprehensive performance metrics
+            const isTestEnvironment = process.env.NODE_ENV === 'test' || process.env.VITEST === 'true';
+            const logLevel = isTestEnvironment ? 'debug' : 'info';
+            deploymentLogger[logLevel]('Parallel deployment with closures performance metrics', {
+                totalDuration: duration,
+                totalResources: enhancedPlan.totalResources,
+                totalClosures: enhancedPlan.totalClosures,
+                parallelLevels: enhancedPlan.levels.length,
+                maxParallelism: enhancedPlan.maxParallelism,
+                averageTimePerResource: enhancedPlan.totalResources > 0 ? Math.round(duration / enhancedPlan.totalResources) : 0,
+                successfulResources: successfulResources.length,
+                failedResources: errors.length,
+                status
+            });
+            this.emitEvent(options, {
+                type: status === 'success' ? 'completed' : 'failed',
+                message: `Deployment with closures ${status} in ${duration}ms (${enhancedPlan.totalClosures} closures + ${enhancedPlan.totalResources} resources across ${enhancedPlan.levels.length} levels)`,
+                timestamp: new Date(),
+            });
+            // Store deployment state for rollback
+            this.deploymentState.set(deploymentId, {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                startTime: new Date(startTime),
+                endTime: new Date(),
+                status: status === 'success' ? 'completed' : status === 'partial' ? 'completed' : 'failed',
+                options,
+            });
+            return {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                duration,
+                status,
+                errors,
+            };
+        }
+        catch (error) {
+            // Re-throw circular dependency errors immediately - these are configuration errors
+            if (error instanceof CircularDependencyError) {
+                throw error;
+            }
+            const duration = Date.now() - startTime;
+            this.emitEvent(options, {
+                type: 'failed',
+                message: `Deployment with closures failed: ${error}`,
+                timestamp: new Date(),
+                error: error,
+            });
+            // Store deployment state even for failed deployments (for rollback)
+            this.deploymentState.set(deploymentId, {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                startTime: new Date(startTime),
+                endTime: new Date(),
+                status: 'failed',
+                options,
+            });
+            return {
+                deploymentId,
+                resources: deployedResources,
+                dependencyGraph: graph.dependencyGraph,
+                duration,
+                status: 'failed',
+                errors: [
+                    {
+                        resourceId: 'deployment',
+                        phase: 'deployment',
+                        error: error,
+                        timestamp: new Date(),
+                    },
+                ],
+            };
+        }
+    } /**
+  
+     * Deploy a single resource
+     */
+    async deploySingleResource(resource, context, options) {
+        const resourceId = resource.id || resource.__resourceId || resource.metadata?.name || 'unknown';
+        const resourceLogger = this.logger.child({
+            resourceId,
+            kind: resource.kind,
+            name: resource.metadata?.name
+        });
+        resourceLogger.debug('Starting single resource deployment');
+        this.emitEvent(options, {
+            type: 'progress',
+            resourceId,
+            message: `Deploying ${resource.kind}/${resource.metadata?.name}`,
+            timestamp: new Date(),
+        });
+        // 1. Resolve all references in the resource
+        let resolvedResource;
+        try {
+            resourceLogger.debug('Resolving resource references', {
+                originalMetadata: resource.metadata
+            });
+            const resolveTimeout = options.timeout || 30000;
+            resolvedResource = (await Promise.race([
+                this.referenceResolver.resolveReferences(resource, context),
+                new Promise((_, reject) => setTimeout(() => reject(new Error('Reference resolution timeout')), resolveTimeout)),
+            ]));
+            resourceLogger.debug('References resolved successfully', {
+                resolvedMetadata: resolvedResource.metadata,
+                hasReadinessEvaluator: !!resolvedResource.readinessEvaluator
+            });
+        }
+        catch (error) {
+            resourceLogger.warn('Reference resolution failed, using original resource', error);
+            resolvedResource = resource;
+        }
+        // 2. Apply namespace if specified, but only if resource doesn't already have one
+        if (options.namespace && resolvedResource.metadata && typeof resolvedResource.metadata.namespace !== 'string') {
+            resourceLogger.debug('Applying namespace from deployment options', {
+                targetNamespace: options.namespace,
+                currentNamespace: resolvedResource.metadata.namespace,
+                currentNamespaceType: typeof resolvedResource.metadata.namespace
+            });
+            // Create a completely new metadata object to avoid proxy issues
+            const newMetadata = {
+                ...resolvedResource.metadata,
+                namespace: options.namespace,
+            };
+            // Preserve the readiness evaluator when creating the new resource
+            const newResolvedResource = {
+                ...resolvedResource,
+                metadata: newMetadata,
+            };
+            // Copy the non-enumerable readiness evaluator if it exists
+            const readinessEvaluator = resolvedResource.readinessEvaluator;
+            if (readinessEvaluator) {
+                Object.defineProperty(newResolvedResource, 'readinessEvaluator', {
+                    value: readinessEvaluator,
+                    enumerable: false,
+                    configurable: true,
+                    writable: false
+                });
+            }
+            resolvedResource = newResolvedResource;
+        }
+        // 3. Apply the resource to the cluster (or simulate for dry run)
+        let appliedResource;
+        if (options.dryRun) {
+            // In dry run mode, don't actually create the resource
+            resourceLogger.debug('Dry run mode: simulating resource creation');
+            appliedResource = {
+                ...resolvedResource,
+                metadata: {
+                    ...resolvedResource.metadata,
+                    uid: 'dry-run-uid',
+                },
+            };
+        }
+        else {
+            // Apply resource with retry logic
+            const retryPolicy = options.retryPolicy || {
+                maxRetries: 3,
+                backoffMultiplier: 2,
+                initialDelay: 1000,
+                maxDelay: 30000,
+            };
+            let lastError;
+            for (let attempt = 0; attempt <= retryPolicy.maxRetries; attempt++) {
+                try {
+                    resourceLogger.debug('Applying resource to cluster', { attempt });
+                    // Check if resource already exists
+                    let existing;
+                    try {
+                        const readResult = await this.k8sApi.read({
+                            apiVersion: resolvedResource.apiVersion,
+                            kind: resolvedResource.kind,
+                            metadata: {
+                                name: resolvedResource.metadata?.name || '',
+                                namespace: resolvedResource.metadata?.namespace || 'default',
+                            },
+                        });
+                        existing = readResult.body;
+                    }
+                    catch (error) {
+                        // If it's a 404, the resource doesn't exist, which is expected for creation
+                        if (error.statusCode !== 404) {
+                            resourceLogger.error('Error checking resource existence', error);
+                            throw error;
+                        }
+                    }
+                    if (existing) {
+                        // Resource exists, use patch for safer updates
+                        resourceLogger.debug('Resource exists, patching');
+                        const patchResult = await this.k8sApi.patch(resolvedResource);
+                        appliedResource = patchResult.body;
+                    }
+                    else {
+                        // Resource does not exist, create it
+                        resourceLogger.debug('Resource does not exist, creating');
+                        const createResult = await this.k8sApi.create(resolvedResource);
+                        appliedResource = createResult.body;
+                    }
+                    resourceLogger.debug('Resource applied successfully', {
+                        appliedName: appliedResource.metadata?.name,
+                        appliedNamespace: appliedResource.metadata?.namespace,
+                        operation: existing ? 'patched' : 'created',
+                        attempt
+                    });
+                    // Success - break out of retry loop
+                    break;
+                }
+                catch (error) {
+                    lastError = error;
+                    resourceLogger.error('Failed to apply resource to cluster', lastError, { attempt });
+                    // If this was the last attempt, throw the error
+                    if (attempt >= retryPolicy.maxRetries) {
+                        throw new ResourceDeploymentError(resolvedResource.metadata?.name || 'unknown', resolvedResource.kind || 'Unknown', lastError);
+                    }
+                    // Calculate delay for next attempt
+                    const delay = Math.min(retryPolicy.initialDelay * retryPolicy.backoffMultiplier ** attempt, retryPolicy.maxDelay);
+                    resourceLogger.debug('Retrying resource deployment', {
+                        attempt: attempt + 1,
+                        maxRetries: retryPolicy.maxRetries,
+                        delay
+                    });
+                    // Wait before retrying
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        // 4. Create deployed resource record
+        const deployedResource = {
+            id: resourceId,
+            kind: resolvedResource.kind || 'Unknown',
+            name: resolvedResource.metadata?.name || 'unknown',
+            namespace: resolvedResource.metadata?.namespace || 'default',
+            manifest: resolvedResource,
+            status: 'deployed',
+            deployedAt: new Date(),
+        };
+        // 5. Wait for resource to be ready if requested
+        if (options.waitForReady !== false) {
+            resourceLogger.debug('Waiting for resource to be ready');
+            await this.waitForResourceReady(deployedResource, options);
+            deployedResource.status = 'ready';
+        }
+        resourceLogger.debug('Single resource deployment completed');
+        return deployedResource;
+    }
+    /**
+     * Wait for a resource to be ready
+     */
+    async waitForResourceReady(deployedResource, options) {
+        const resourceKey = `${deployedResource.kind}/${deployedResource.name}/${deployedResource.namespace}`;
+        // Check if already marked as ready
+        if (deployedResource.status === 'ready' || this.readyResources.has(resourceKey)) {
+            this.logger.debug('Resource already marked as ready', { resourceKey });
+            return;
+        }
+        // Safety-first approach: check for readiness evaluator before starting the wait loop
+        const readinessEvaluator = deployedResource.manifest.readinessEvaluator;
+        // Debug logging removed
+        if (!readinessEvaluator) {
+            const errorMessage = `Resource ${deployedResource.kind}/${deployedResource.name} does not have a factory-provided readiness evaluator`;
+            this.logger.error('Missing factory-provided readiness evaluator');
+            throw new Error(errorMessage);
+        }
+        const startTime = Date.now();
+        const timeout = options.timeout || 300000; // 5 minutes default
+        let lastStatus = null;
+        while (Date.now() - startTime < timeout) {
+            try {
+                // Use custom readiness evaluator
+                const { body: liveResource } = await this.k8sApi.read({
+                    apiVersion: deployedResource.manifest.apiVersion || '',
+                    kind: deployedResource.kind,
+                    metadata: {
+                        name: deployedResource.name,
+                        namespace: deployedResource.namespace,
+                    },
+                });
+                const result = readinessEvaluator(liveResource);
+                if (typeof result === 'boolean') {
+                    if (result) {
+                        this.readyResources.add(resourceKey);
+                        this.emitEvent(options, {
+                            type: 'resource-ready',
+                            resourceId: deployedResource.id,
+                            message: `${deployedResource.kind}/${deployedResource.name} ready (custom evaluator)`,
+                            timestamp: new Date(),
+                        });
+                        return;
+                    }
+                }
+                else if (result && typeof result === 'object' && 'ready' in result) {
+                    lastStatus = result;
+                    if (result.ready) {
+                        this.readyResources.add(resourceKey);
+                        this.emitEvent(options, {
+                            type: 'resource-ready',
+                            resourceId: deployedResource.id,
+                            message: result.message || `${deployedResource.kind}/${deployedResource.name} ready (custom evaluator)`,
+                            timestamp: new Date(),
+                        });
+                        return;
+                    }
+                }
+                // Emit status update if we have status information
+                if (lastStatus && typeof lastStatus === 'object' && 'message' in lastStatus) {
+                    this.emitEvent(options, {
+                        type: 'resource-status',
+                        resourceId: deployedResource.id,
+                        message: `${deployedResource.kind}/${deployedResource.name}: ${lastStatus.message}`,
+                        timestamp: new Date(),
+                    });
+                }
+                // Wait before next check
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+            catch (error) {
+                // Emit error status event
+                this.emitEvent(options, {
+                    type: 'resource-status',
+                    resourceId: deployedResource.id,
+                    message: `Unable to read resource status: ${error instanceof Error ? error.message : String(error)}`,
+                    timestamp: new Date(),
+                });
+                // If we can't read the resource, it's not ready yet
+                await new Promise(resolve => setTimeout(resolve, 2000));
+            }
+        }
+        // Timeout reached
+        const timeoutMessage = lastStatus
+            ? `Timeout waiting for ${deployedResource.kind}/${deployedResource.name}: ${lastStatus.message}`
+            : `Timeout waiting for ${deployedResource.kind}/${deployedResource.name} to be ready`;
+        throw new Error(timeoutMessage);
+    }
+    /**
+     * Rollback deployed resources
+     */
+    async rollbackDeployedResources(deployedResources, options) {
+        this.emitEvent(options, {
+            type: 'rollback',
+            message: 'Starting rollback of deployed resources',
+            timestamp: new Date(),
+        });
+        const rolledBackResources = [];
+        const errors = [];
+        // Rollback in reverse order
+        const reversedResources = [...deployedResources].reverse();
+        for (const resource of reversedResources) {
+            // Only try to rollback resources that were actually deployed (not failed)
+            if (resource.status === 'failed') {
+                continue; // Skip resources that failed to deploy
+            }
+            try {
+                await this.k8sApi.delete({
+                    apiVersion: resource.manifest.apiVersion || '',
+                    kind: resource.kind,
+                    metadata: {
+                        name: resource.name,
+                        namespace: resource.namespace,
+                    },
+                });
+                rolledBackResources.push(`${resource.kind}/${resource.name}`);
+            }
+            catch (error) {
+                // Log and collect errors for individual resource deletion failures
+                this.logger.warn('Failed to delete resource during rollback', {
+                    error: error,
+                    resourceId: resource.id,
+                    kind: resource.kind,
+                    name: resource.name
+                });
+                errors.push({
+                    resourceId: resource.id,
+                    phase: 'rollback',
+                    error: error,
+                    timestamp: new Date(),
+                });
+            }
+        }
+        return { rolledBackResources, errors };
+    }
+    /**
+     * Generate a unique deployment ID
+     */
+    generateDeploymentId() {
+        return `deployment-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    }
+    /**
+     * Emit deployment events
+     */
+    emitEvent(options, event) {
+        if (options.progressCallback) {
+            options.progressCallback(event);
+        }
+    }
+    /**
+     * Deploy a single resource (legacy method for compatibility)
+     */
+    async deployResource(resource, options) {
+        const context = {
+            deployedResources: [],
+            kubeClient: this.kubeClient,
+            ...(options.namespace && { namespace: options.namespace }),
+            timeout: options.timeout || 30000,
+        };
+        return this.deploySingleResource(resource, context, options);
+    }
+    /**
+     * Delete a resource from the cluster
+     */
+    async deleteResource(resource) {
+        const deleteLogger = this.logger.child({
+            resourceId: resource.id,
+            kind: resource.kind,
+            name: resource.name
+        });
+        try {
+            await this.k8sApi.delete({
+                apiVersion: resource.manifest.apiVersion || '',
+                kind: resource.kind,
+                metadata: {
+                    name: resource.name,
+                    namespace: resource.namespace,
+                },
+            });
+            // Wait for resource to be deleted
+            const timeout = 30000; // 30 seconds
+            const startTime = Date.now();
+            while (Date.now() - startTime < timeout) {
+                try {
+                    await this.k8sApi.read({
+                        apiVersion: resource.manifest.apiVersion || '',
+                        kind: resource.kind,
+                        metadata: {
+                            name: resource.name,
+                            namespace: resource.namespace,
+                        },
+                    });
+                    // Resource still exists, wait and try again
+                    await new Promise((resolve) => setTimeout(resolve, 1000));
+                }
+                catch (error) {
+                    // Resource not found, deletion successful
+                    if (this.isNotFoundError(error)) {
+                        deleteLogger.debug('Resource successfully deleted');
+                        return;
+                    }
+                    throw error;
+                }
+            }
+            throw new Error(`Timeout waiting for resource ${resource.kind}/${resource.name} to be deleted`);
+        }
+        catch (error) {
+            deleteLogger.error('Failed to delete resource', error);
+            throw error;
+        }
+    }
+    /**
+     * Wait for resource readiness (legacy method for compatibility)
+     */
+    async waitForResourceReadiness(resource, options) {
+        return this.waitForResourceReady(resource, options);
+    }
+    /**
+     * Rollback a deployment by ID
+     */
+    async rollback(deploymentId) {
+        const startTime = Date.now();
+        const deploymentRecord = this.deploymentState.get(deploymentId);
+        if (!deploymentRecord) {
+            throw new Error(`Deployment ${deploymentId} not found. Cannot rollback.`);
+        }
+        try {
+            const { rolledBackResources, errors } = await this.rollbackDeployedResources(deploymentRecord.resources, deploymentRecord.options);
+            const status = errors.length === 0 ? 'success' :
+                rolledBackResources.length > 0 ? 'partial' : 'failed';
+            return {
+                deploymentId,
+                rolledBackResources,
+                duration: Date.now() - startTime,
+                status,
+                errors,
+            };
+        }
+        catch (error) {
+            // This shouldn't happen now since rollbackDeployedResources handles its own errors
+            return {
+                deploymentId,
+                rolledBackResources: [],
+                duration: Date.now() - startTime,
+                status: 'failed',
+                errors: [{
+                        resourceId: deploymentId,
+                        phase: 'rollback',
+                        error: error,
+                        timestamp: new Date(),
+                    }],
+            };
+        }
+    }
+    /**
+     * Get deployment status by ID
+     */
+    async getStatus(deploymentId) {
+        const deploymentRecord = this.deploymentState.get(deploymentId);
+        if (!deploymentRecord) {
+            return {
+                deploymentId,
+                status: 'unknown',
+                startTime: new Date(),
+                resources: [],
+            };
+        }
+        const result = {
+            deploymentId,
+            status: deploymentRecord.status === 'completed' ? 'completed' :
+                deploymentRecord.status === 'failed' ? 'failed' : 'running',
+            startTime: deploymentRecord.startTime,
+            resources: deploymentRecord.resources,
+        };
+        if (deploymentRecord.endTime) {
+            result.endTime = deploymentRecord.endTime;
+            result.duration = deploymentRecord.endTime.getTime() - deploymentRecord.startTime.getTime();
+        }
+        return result;
+    }
+    /**
+     * Check if an error is a "not found" error
+     */
+    isNotFoundError(error) {
+        if (error && typeof error === 'object') {
+            const k8sError = error;
+            return k8sError.statusCode === 404 || k8sError.body?.code === 404;
+        }
+        return false;
+    }
+    /**
+     * Wait for CRD establishment if the resource is a custom resource
+     */
+    async waitForCRDIfCustomResource(resource, options, logger) {
+        // Skip if this is not a custom resource
+        if (!this.isCustomResource(resource)) {
+            return;
+        }
+        const crdName = await this.getCRDNameForResource(resource);
+        if (!crdName) {
+            logger.warn('Could not determine CRD name for custom resource', {
+                kind: resource.kind,
+                apiVersion: resource.apiVersion
+            });
+            return;
+        }
+        logger.debug('Custom resource detected, waiting for CRD establishment', {
+            resourceKind: resource.kind,
+            crdName
+        });
+        await this.waitForCRDEstablishment({ metadata: { name: crdName } }, options, logger);
+        logger.debug('CRD established, proceeding with custom resource deployment', {
+            resourceKind: resource.kind,
+            crdName
+        });
+    }
+    /**
+     * Check if a resource is a CustomResourceDefinition
+     */
+    isCRD(resource) {
+        return resource.kind === 'CustomResourceDefinition' &&
+            resource.apiVersion?.includes('apiextensions.k8s.io');
+    }
+    /**
+     * Check if a resource is a custom resource (not a built-in Kubernetes resource)
+     */
+    isCustomResource(resource) {
+        if (!resource.apiVersion || !resource.kind) {
+            return false;
+        }
+        // Built-in Kubernetes API groups that are NOT custom resources
+        const builtInApiGroups = [
+            'v1', // Core API group
+            'apps/v1',
+            'extensions/v1beta1',
+            'networking.k8s.io/v1',
+            'policy/v1',
+            'rbac.authorization.k8s.io/v1',
+            'storage.k8s.io/v1',
+            'apiextensions.k8s.io/v1', // CRDs themselves
+            'admissionregistration.k8s.io/v1',
+            'apiregistration.k8s.io/v1',
+            'authentication.k8s.io/v1',
+            'authorization.k8s.io/v1',
+            'autoscaling/v1',
+            'autoscaling/v2',
+            'batch/v1',
+            'certificates.k8s.io/v1',
+            'coordination.k8s.io/v1',
+            'discovery.k8s.io/v1',
+            'events.k8s.io/v1',
+            'flowcontrol.apiserver.k8s.io/v1beta3',
+            'node.k8s.io/v1',
+            'scheduling.k8s.io/v1'
+        ];
+        return !builtInApiGroups.includes(resource.apiVersion);
+    }
+    /**
+     * Get the CRD name for a custom resource
+     */
+    async getCRDNameForResource(resource) {
+        if (!resource.apiVersion || !resource.kind) {
+            return null;
+        }
+        // Only return CRD name for custom resources
+        if (!this.isCustomResource(resource)) {
+            return null;
+        }
+        // Extract group from apiVersion (e.g., "example.com/v1" -> "example.com")
+        const apiVersionParts = resource.apiVersion.split('/');
+        const group = apiVersionParts.length > 1 ? apiVersionParts[0] : '';
+        if (!group) {
+            return null; // Core API resources don't have CRDs
+        }
+        try {
+            // Try to find the CRD by querying the API
+            const crds = await this.k8sApi.list('apiextensions.k8s.io/v1', 'CustomResourceDefinition');
+            // Look for a CRD that matches our group and kind
+            const matchingCrd = crds.body?.items?.find((crd) => {
+                const crdSpec = crd.spec;
+                return crdSpec?.group === group &&
+                    crdSpec?.names?.kind === resource.kind;
+            });
+            if (matchingCrd) {
+                return matchingCrd.metadata?.name;
+            }
+        }
+        catch (error) {
+            // If we can't query CRDs, fall back to heuristic
+            console.warn('Failed to query CRDs, using heuristic for CRD name generation:', error);
+        }
+        // Fallback: Convert Kind to plural lowercase (simple heuristic)
+        const kind = resource.kind.toLowerCase();
+        const plural = kind.endsWith('s') ? kind : `${kind}s`;
+        return `${plural}.${group}`;
+    }
+    /**
+     * Wait for a CRD to be established in the cluster
+     */
+    async waitForCRDEstablishment(crd, options, logger) {
+        const crdName = crd.metadata?.name;
+        const timeout = options.timeout || 300000; // 5 minutes default
+        const startTime = Date.now();
+        const pollInterval = 2000; // 2 seconds
+        logger.debug('Waiting for CRD to exist and be established', { crdName, timeout });
+        while (Date.now() - startTime < timeout) {
+            try {
+                // Check if CRD is established by reading its status
+                const crdStatus = await this.k8sApi.read({
+                    apiVersion: 'apiextensions.k8s.io/v1',
+                    kind: 'CustomResourceDefinition',
+                    metadata: { name: crdName } // CRDs are cluster-scoped, no namespace needed
+                });
+                const conditions = crdStatus.body?.status?.conditions || [];
+                const establishedCondition = conditions.find((c) => c.type === 'Established');
+                if (establishedCondition?.status === 'True') {
+                    logger.debug('CRD exists and is established', { crdName });
+                    return;
+                }
+                logger.debug('CRD exists but not yet established, waiting...', {
+                    crdName,
+                    establishedStatus: establishedCondition?.status || 'unknown'
+                });
+            }
+            catch (error) {
+                // CRD might not exist yet (e.g., being installed by a closure)
+                // This is expected in scenarios where closures install CRDs
+                logger.debug('CRD not found yet, waiting for it to be created...', {
+                    crdName,
+                    error: error.message
+                });
+            }
+            // Wait before next poll
+            await new Promise(resolve => setTimeout(resolve, pollInterval));
+        }
+        // Timeout reached
+        throw new Error(`Timeout waiting for CRD ${crdName} to be established after ${timeout}ms`);
+    }
+}
+//# sourceMappingURL=engine.js.map