typekro 0.1.0

package/dist/core/deployment/kro-factory.js

@@ -0,0 +1,837 @@
+/**
+ * KroResourceFactory implementation for Kro deployment mode
+ *
+ * This factory handles deployment via Kro ResourceGraphDefinitions,
+ * using the Kro controller for dependency resolution and resource management.
+ */
+import * as k8s from '@kubernetes/client-node';
+import { getComponentLogger } from '../logging/index.js';
+import { createKubernetesClientProvider, createKubernetesClientProviderWithKubeConfig } from '../kubernetes/client-provider.js';
+import { createSchemaProxy } from '../references/index.js';
+import { generateKroSchemaFromArktype } from '../serialization/schema.js';
+import { serializeResourceGraphToYaml } from '../serialization/yaml.js';
+import { DirectDeploymentEngine } from './engine.js';
+import { DeploymentMode } from '../references/index.js';
+import { resourceGraphDefinition } from '../../factories/kro/resource-graph-definition.js';
+import { kroCustomResourceDefinition } from '../../factories/kro/kro-crd.js';
+import { kroCustomResource } from '../../factories/kro/kro-custom-resource.js';
+import { ensureResourceTypeRegistered, KroTypeKroDeployer, createAlchemyResourceId } from '../../alchemy/deployment.js';
+import { isKubernetesRef } from '../dependencies/type-guards.js';
+/**
+ * KroResourceFactory implementation
+ *
+ * Handles deployment via Kro ResourceGraphDefinitions. The RGD is deployed once,
+ * and then instances are created as custom resources that the Kro controller processes.
+ */
+export class KroResourceFactoryImpl {
+    mode = 'kro';
+    name;
+    namespace;
+    isAlchemyManaged;
+    rgdName;
+    schema;
+    resources;
+    closures;
+    schemaDefinition;
+    statusMappings;
+    alchemyScope;
+    factoryOptions;
+    logger = getComponentLogger('kro-factory');
+    clientProvider;
+    constructor(name, resources, schemaDefinition, statusMappings, options = {}) {
+        this.name = name;
+        this.namespace = options.namespace || 'default';
+        this.alchemyScope = options.alchemyScope;
+        this.isAlchemyManaged = !!options.alchemyScope;
+        this.rgdName = this.convertToKubernetesName(name); // Convert to valid Kubernetes resource name
+        this.resources = resources;
+        this.closures = options.closures || {};
+        this.schemaDefinition = schemaDefinition;
+        this.statusMappings = statusMappings;
+        this.factoryOptions = options;
+        this.schema = createSchemaProxy();
+        // Validate closures for Kro mode - detect KubernetesRef inputs and raise clear errors
+        this.validateClosuresForKroMode();
+        // Don't initialize client provider in constructor - do it lazily when needed
+        // This allows tests to create factories without requiring a kubeconfig
+    }
+    /**
+     * Validate closures for Kro mode compatibility
+     * Kro mode only supports static values - no dynamic references (KubernetesRef)
+     */
+    validateClosuresForKroMode() {
+        if (Object.keys(this.closures).length === 0) {
+            return; // No closures to validate
+        }
+        // For Kro mode, we need to validate that closures don't contain dynamic references
+        // This is a static analysis - we can't execute the closures to check their arguments
+        // Instead, we'll validate when closures are executed during deployment
+        this.logger.debug('Kro factory initialized with closures', {
+            closureCount: Object.keys(this.closures).length,
+            closureNames: Object.keys(this.closures)
+        });
+    }
+    /**
+     * Validate closure arguments for Kro mode compatibility
+     * This is called during deployment when we have access to the actual arguments
+     */
+    validateClosureArgumentsForKroMode(closureName, config) {
+        const errors = [];
+        // Recursively check for KubernetesRef objects in the closure configuration
+        const checkForKubernetesRefs = (obj, path = '') => {
+            if (isKubernetesRef(obj)) {
+                errors.push(`Found KubernetesRef at ${path || 'root'}`);
+                return;
+            }
+            if (obj && typeof obj === 'object' && !Array.isArray(obj)) {
+                for (const [key, value] of Object.entries(obj)) {
+                    const newPath = path ? `${path}.${key}` : key;
+                    checkForKubernetesRefs(value, newPath);
+                }
+            }
+            else if (Array.isArray(obj)) {
+                obj.forEach((item, index) => {
+                    const newPath = path ? `${path}[${index}]` : `[${index}]`;
+                    checkForKubernetesRefs(item, newPath);
+                });
+            }
+        };
+        checkForKubernetesRefs(config);
+        if (errors.length > 0) {
+            const errorMessage = [
+                `Kro mode does not support dynamic references in YAML closures.`,
+                `Found KubernetesRef in closure '${closureName}':`,
+                ...errors.map(error => `  - ${error}`),
+                ``,
+                `Kro mode limitations:`,
+                `  - YAML closures must use static values only`,
+                `  - Dynamic references (schema.spec.*, resource.status.*) are not supported`,
+                `  - Use static strings, numbers, and objects instead`,
+                ``,
+                `Solutions:`,
+                `  1. Use static values: namespace: 'my-namespace' instead of namespace: schema.spec.namespace`,
+                `  2. Switch to Direct mode: await graph.factory('direct', options)`,
+                `  3. Move dynamic logic to Enhanced<> resources instead of closures`,
+                ``,
+                `Example of Kro-compatible closure:`,
+                `  yamlFile({`,
+                `    name: 'static-config',`,
+                `    path: 'git:github.com/org/repo/config.yaml@main',`,
+                `    namespace: 'kro-system' // Static string - OK`,
+                `  })`,
+            ].join('\n');
+            throw new Error(errorMessage);
+        }
+    }
+    /**
+     * Convert camelCase resource graph name to valid Kubernetes resource name (kebab-case)
+     */
+    convertToKubernetesName(name) {
+        // Validate input name
+        if (!name || typeof name !== 'string') {
+            throw new Error(`Invalid resource graph name: ${JSON.stringify(name)}. Resource graph name must be a non-empty string.`);
+        }
+        const trimmedName = name.trim();
+        if (trimmedName.length === 0) {
+            throw new Error(`Invalid resource graph name: Resource graph name cannot be empty or whitespace-only.`);
+        }
+        // Convert to kebab-case and validate result
+        const kubernetesName = trimmedName
+            .replace(/([a-z])([A-Z])/g, '$1-$2') // Insert dash before capital letters
+            .toLowerCase(); // Convert to lowercase
+        // Validate Kubernetes naming conventions
+        if (!/^[a-z0-9]([-a-z0-9]*[a-z0-9])?$/.test(kubernetesName)) {
+            throw new Error(`Invalid resource graph name: "${name}" converts to "${kubernetesName}" which is not a valid Kubernetes resource name. Names must consist of lowercase alphanumeric characters or '-', and must start and end with an alphanumeric character.`);
+        }
+        if (kubernetesName.length > 253) {
+            throw new Error(`Invalid resource graph name: "${name}" converts to "${kubernetesName}" which exceeds the 253 character limit for Kubernetes resource names.`);
+        }
+        return kubernetesName;
+    }
+    /**
+     * Get or create the Kubernetes client provider (lazy initialization)
+     */
+    getClientProvider() {
+        if (!this.clientProvider) {
+            this.clientProvider = this.createClientProvider(this.factoryOptions);
+        }
+        return this.clientProvider;
+    }
+    /**
+     * Create and configure the Kubernetes client provider
+     */
+    createClientProvider(options) {
+        // If a pre-configured kubeConfig is provided, use it directly
+        if (options.kubeConfig) {
+            this.logger.debug('Using pre-configured KubeConfig from factory options');
+            return createKubernetesClientProviderWithKubeConfig(options.kubeConfig);
+        }
+        // Create client provider with configuration from factory options
+        const clientConfig = {
+            ...(options.skipTLSVerify !== undefined && { skipTLSVerify: options.skipTLSVerify }),
+            // Add other configuration options as needed
+        };
+        this.logger.debug('Creating new KubernetesClientProvider with configuration', {
+            skipTLSVerify: clientConfig.skipTLSVerify,
+        });
+        return createKubernetesClientProvider(clientConfig);
+    }
+    /**
+     * Get the Kubernetes config from the centralized provider
+     */
+    getKubeConfig() {
+        const clientProvider = this.getClientProvider();
+        return clientProvider.getKubeConfig();
+    }
+    /**
+     * Deploy a new instance by creating a custom resource
+     */
+    async deploy(spec) {
+        // Validate spec against ArkType schema
+        const validationResult = this.schemaDefinition.spec(spec);
+        if (validationResult instanceof Error) {
+            throw new Error(`Invalid spec: ${validationResult.message}`);
+        }
+        // Execute closures before RGD creation (Kro mode requirement)
+        await this.executeClosuresBeforeRGD(spec);
+        if (this.isAlchemyManaged) {
+            return this.deployWithAlchemy(spec);
+        }
+        else {
+            return this.deployDirect(spec);
+        }
+    }
+    /**
+     * Execute closures before RGD creation (Kro mode requirement)
+     * Closures must execute before ResourceGraphDefinition is created
+     */
+    async executeClosuresBeforeRGD(spec) {
+        if (Object.keys(this.closures).length === 0) {
+            return []; // No closures to execute
+        }
+        this.logger.info('Executing closures before RGD creation', {
+            closureCount: Object.keys(this.closures).length
+        });
+        // First, validate all closures before creating any API clients
+        // The closures returned by the resource builder are deployment closures that expect a DeploymentContext
+        // We need to execute them with a mock context to trigger validation
+        const mockDeploymentContext = {
+            kubernetesApi: null, // Not needed for validation
+            namespace: this.namespace,
+            deployedResources: new Map(),
+            resolveReference: async (ref) => {
+                throw new Error(`Kro mode does not support dynamic reference resolution. Found reference: ${ref.resourceId}.${ref.fieldPath}`);
+            }
+        };
+        for (const [closureName, closure] of Object.entries(this.closures)) {
+            try {
+                // Execute the deployment closure with mock context to trigger validation
+                await closure(mockDeploymentContext);
+            }
+            catch (error) {
+                // If validation fails, throw the validation error immediately
+                if (error instanceof Error && error.message.includes('Kro mode does not support dynamic reference resolution')) {
+                    throw error;
+                }
+                // For other errors, wrap them with context
+                throw new Error(`Failed to validate closure '${closureName}': ${error}`);
+            }
+        }
+        const allResults = [];
+        // Only create deployment context after validation passes
+        const deploymentContext = {
+            kubernetesApi: this.getKubeConfig().makeApiClient(k8s.KubernetesObjectApi),
+            ...(this.alchemyScope && { alchemyScope: this.alchemyScope }),
+            namespace: this.namespace,
+            deployedResources: new Map(), // Empty for pre-RGD execution
+            resolveReference: async (ref) => {
+                throw new Error(`Kro mode does not support dynamic reference resolution. Found reference: ${ref.resourceId}.${ref.fieldPath}`);
+            }
+        };
+        // Execute closures sequentially to maintain order
+        for (const [closureName, closure] of Object.entries(this.closures)) {
+            try {
+                this.logger.debug('Executing closure', { name: closureName });
+                // Note: We can't validate closure arguments here because we don't have access to them
+                // The validation happens inside the closure when it processes its config
+                // This is a limitation of the closure pattern, but the error messages will be clear
+                const results = await closure(deploymentContext);
+                allResults.push(...results);
+                this.logger.info('Closure executed successfully', {
+                    name: closureName,
+                    resourceCount: results.length
+                });
+            }
+            catch (error) {
+                // Check if this is a KubernetesRef validation error and enhance it
+                if (error instanceof Error && error.message.includes('KubernetesRef')) {
+                    this.logger.error('Closure validation failed - dynamic references not supported in Kro mode', {
+                        name: closureName,
+                        message: error.message
+                    });
+                    throw error; // Re-throw with original detailed message
+                }
+                this.logger.error('Closure execution failed', { name: closureName, message: error instanceof Error ? error.message : String(error) });
+                throw new Error(`Failed to execute closure '${closureName}': ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        this.logger.info('All closures executed successfully', {
+            totalResources: allResults.length
+        });
+        return allResults;
+    }
+    /**
+     * Deploy directly to Kubernetes using DirectDeploymentEngine
+     */
+    async deployDirect(spec) {
+        // Ensure RGD is deployed first
+        await this.ensureRGDDeployed();
+        // Create DirectDeploymentEngine with KRO mode for CEL string conversion
+        const deploymentEngine = new DirectDeploymentEngine(this.getKubeConfig(), undefined, undefined, DeploymentMode.KRO);
+        // Create custom resource instance
+        const instanceName = this.generateInstanceName(spec);
+        const customResourceData = this.createCustomResourceInstance(instanceName, spec);
+        // Wrap with kroCustomResource factory to get Enhanced object with readiness evaluation
+        const enhancedCustomResource = kroCustomResource({
+            apiVersion: customResourceData.apiVersion,
+            kind: customResourceData.kind,
+            metadata: {
+                name: customResourceData.metadata.name,
+                namespace: customResourceData.metadata.namespace,
+            },
+            spec: customResourceData.spec,
+        });
+        // Deploy using DirectDeploymentEngine with built-in waitForReady logic
+        const deployableResource = {
+            ...enhancedCustomResource,
+            id: instanceName,
+            metadata: {
+                ...enhancedCustomResource.metadata,
+                name: instanceName,
+                namespace: this.namespace,
+            },
+            spec: customResourceData.spec, // Use spec directly from customResourceData to ensure it's preserved
+        };
+        // Preserve the readiness evaluator (non-enumerable property)
+        const readinessEvaluator = enhancedCustomResource.readinessEvaluator;
+        if (readinessEvaluator) {
+            Object.defineProperty(deployableResource, 'readinessEvaluator', {
+                value: readinessEvaluator,
+                enumerable: false,
+                configurable: false,
+                writable: false
+            });
+        }
+        // Deploy without waiting for readiness - we'll handle that ourselves
+        const _deployedResource = await deploymentEngine.deployResource(deployableResource, {
+            mode: 'kro',
+            namespace: this.namespace,
+            waitForReady: false, // We'll handle Kro-specific readiness ourselves
+            timeout: this.factoryOptions.timeout || 300000,
+        });
+        // Handle Kro-specific readiness checking if requested
+        if (this.factoryOptions.waitForReady ?? true) {
+            await this.waitForKroInstanceReady(instanceName, this.factoryOptions.timeout || 600000); // 10 minutes
+        }
+        // Create Enhanced proxy for the deployed instance
+        return await this.createEnhancedProxy(spec, instanceName);
+    }
+    /**
+     * Deploy using type-safe alchemy resource wrapping
+     *
+     * In alchemy mode, the RGD gets one typed alchemy Resource and each instance gets another
+     */
+    async deployWithAlchemy(spec) {
+        if (!this.alchemyScope) {
+            throw new Error('Alchemy scope is required for alchemy deployment');
+        }
+        // Use static registration functions
+        // Create deployer instance using DirectDeploymentEngine with KRO mode
+        const kroEngine = new DirectDeploymentEngine(this.getKubeConfig(), undefined, undefined, DeploymentMode.KRO);
+        const deployer = new KroTypeKroDeployer(kroEngine);
+        // 1. Ensure RGD is deployed via alchemy (once per factory)
+        const kroSchema = generateKroSchemaFromArktype(this.name, this.schemaDefinition, this.resources, this.statusMappings);
+        const rgdManifest = {
+            apiVersion: 'kro.run/v1alpha1',
+            kind: 'ResourceGraphDefinition',
+            metadata: {
+                name: this.rgdName,
+                namespace: this.namespace,
+            },
+            spec: {
+                schema: kroSchema,
+                resources: Object.values(this.resources).map(resource => ({
+                    id: resource.id || resource.metadata?.name || 'unknown',
+                    template: resource,
+                })),
+            },
+        };
+        // Register RGD type dynamically
+        const rgdEnhanced = resourceGraphDefinition(rgdManifest);
+        const RGDProvider = ensureResourceTypeRegistered(rgdEnhanced);
+        const rgdId = createAlchemyResourceId(rgdEnhanced, this.namespace);
+        await RGDProvider(rgdId, {
+            resource: rgdEnhanced,
+            namespace: this.namespace,
+            deployer: deployer,
+            options: {
+                waitForReady: true,
+                timeout: 60000, // RGD should be ready quickly
+            },
+        });
+        // 2. Create instance via alchemy (once per deploy call)
+        const instanceName = this.generateInstanceName(spec);
+        const crdInstanceManifest = this.createCustomResourceInstance(instanceName, spec);
+        // Register CRD instance type dynamically
+        const CRDInstanceProvider = ensureResourceTypeRegistered(crdInstanceManifest);
+        const instanceId = createAlchemyResourceId(crdInstanceManifest, this.namespace);
+        await CRDInstanceProvider(instanceId, {
+            resource: crdInstanceManifest,
+            namespace: this.namespace,
+            deployer: deployer,
+            options: {
+                waitForReady: this.factoryOptions.waitForReady ?? true,
+                timeout: this.factoryOptions.timeout ?? 300000,
+            },
+        });
+        // Create Enhanced proxy for the deployed instance
+        return await this.createEnhancedProxy(spec, instanceName);
+    }
+    /**
+     * Get all deployed instances
+     */
+    async getInstances() {
+        const kubeConfig = this.getKubeConfig();
+        const customApi = kubeConfig.makeApiClient(k8s.CustomObjectsApi);
+        try {
+            // The schema definition should contain just the version part (e.g., 'v1alpha1')
+            // If it somehow contains the full API version, extract just the version part
+            const version = this.schemaDefinition.apiVersion.includes('/')
+                ? this.schemaDefinition.apiVersion.split('/')[1] || this.schemaDefinition.apiVersion
+                : this.schemaDefinition.apiVersion;
+            const listResponse = await customApi.listNamespacedCustomObject('kro.run', version, this.namespace, `${this.schemaDefinition.kind.toLowerCase()}s` // Pluralize the kind
+            );
+            const instances = listResponse.body.items || [];
+            return await Promise.all(instances.map(async (instance) => {
+                return await this.createEnhancedProxy(instance.spec, instance.metadata.name);
+            }));
+        }
+        catch (error) {
+            const k8sError = error;
+            // If the CRD doesn't exist yet or there are no instances, return empty array
+            if (k8sError.message?.includes('not found') ||
+                k8sError.message?.includes('404') ||
+                k8sError.body?.includes('not found') ||
+                k8sError.body?.includes('404') ||
+                k8sError.statusCode === 404 ||
+                String(error).includes('404') ||
+                String(error).includes('not found')) {
+                return [];
+            }
+            throw new Error(`Failed to list instances: ${k8sError.message || String(error)}`);
+        }
+    }
+    /**
+     * Delete a specific instance by name
+     */
+    async deleteInstance(name) {
+        const k8sApi = this.getKubeConfig().makeApiClient(k8s.KubernetesObjectApi);
+        const apiVersion = this.schemaDefinition.apiVersion.includes('/')
+            ? this.schemaDefinition.apiVersion
+            : `kro.run/${this.schemaDefinition.apiVersion}`;
+        try {
+            await k8sApi.delete({
+                apiVersion,
+                kind: this.schemaDefinition.kind,
+                metadata: {
+                    name,
+                    namespace: this.namespace,
+                },
+            });
+        }
+        catch (error) {
+            const k8sError = error;
+            if (k8sError.statusCode !== 404) {
+                throw new Error(`Failed to delete instance ${name}: ${k8sError.message || String(error)}`);
+            }
+            // Instance already deleted, ignore 404
+        }
+    }
+    /**
+     * Get factory status
+     */
+    async getStatus() {
+        const instances = await this.getInstances();
+        const rgdStatus = await this.getRGDStatus();
+        return {
+            name: this.name,
+            mode: this.mode,
+            isAlchemyManaged: this.isAlchemyManaged,
+            namespace: this.namespace,
+            instanceCount: instances.length,
+            health: rgdStatus.phase === 'ready' ? 'healthy' : 'degraded',
+        };
+    }
+    /**
+     * Get ResourceGraphDefinition status
+     */
+    async getRGDStatus() {
+        const k8sApi = this.getKubeConfig().makeApiClient(k8s.KubernetesObjectApi);
+        try {
+            const response = await k8sApi.read({
+                apiVersion: 'kro.run/v1alpha1',
+                kind: 'ResourceGraphDefinition',
+                metadata: {
+                    name: this.rgdName,
+                    namespace: this.namespace,
+                },
+            });
+            const rgd = response.body;
+            // Map Kro's state to our phase enum
+            let phase = 'pending';
+            if (rgd.status?.state === 'Active') {
+                phase = 'ready';
+            }
+            else if (rgd.status?.state === 'Inactive') {
+                // Check if it's failed or just pending
+                const hasFailedCondition = rgd.status?.conditions?.some(c => c.status === 'False');
+                phase = hasFailedCondition ? 'failed' : 'pending';
+            }
+            return {
+                name: this.rgdName,
+                phase,
+                conditions: rgd.status?.conditions || [],
+                observedGeneration: rgd.status?.observedGeneration || 0,
+            };
+        }
+        catch (error) {
+            const k8sError = error;
+            if (k8sError.statusCode === 404) {
+                return {
+                    name: this.rgdName,
+                    phase: 'pending',
+                    conditions: [],
+                };
+            }
+            throw new Error(`Failed to get RGD status: ${k8sError.message || String(error)}`);
+        }
+    }
+    /**
+     * Implementation of overloaded toYaml method
+     */
+    toYaml(spec) {
+        if (spec) {
+            // Generate CRD instance YAML
+            const instanceName = this.generateInstanceName(spec);
+            const customResource = this.createCustomResourceInstance(instanceName, spec);
+            return `apiVersion: ${customResource.apiVersion}
+kind: ${customResource.kind}
+metadata:
+  name: ${customResource.metadata.name}
+  namespace: ${customResource.metadata.namespace}
+spec:
+${Object.entries(spec).map(([key, value]) => `  ${key}: ${typeof value === 'string' ? `"${value}"` : value}`).join('\n')}`;
+        }
+        else {
+            // Generate RGD YAML
+            const kroSchema = generateKroSchemaFromArktype(this.name, this.schemaDefinition, this.resources, this.statusMappings);
+            return serializeResourceGraphToYaml(this.rgdName, this.resources, { namespace: this.namespace }, kroSchema);
+        }
+    }
+    /**
+     * Ensure the ResourceGraphDefinition is deployed using DirectDeploymentEngine
+     */
+    async ensureRGDDeployed() {
+        // Create DirectDeploymentEngine instance with KRO mode for CEL string generation
+        const deploymentEngine = new DirectDeploymentEngine(this.getKubeConfig(), undefined, undefined, DeploymentMode.KRO);
+        // Create the RGD using the same serialization logic as toYaml()
+        const kroSchema = generateKroSchemaFromArktype(this.name, this.schemaDefinition, this.resources, this.statusMappings);
+        const rgdYaml = serializeResourceGraphToYaml(this.rgdName, this.resources, { namespace: this.namespace }, kroSchema);
+        // Parse the YAML to get the RGD object
+        const rgdManifests = k8s.loadAllYaml(rgdYaml);
+        const rgdManifest = rgdManifests[0];
+        // Ensure the RGD has the required properties for deployment
+        const rgdWithMetadata = {
+            ...rgdManifest,
+            metadata: {
+                ...rgdManifest.metadata,
+                name: this.rgdName,
+                namespace: this.namespace,
+            }
+        };
+        // Create Enhanced RGD with readiness evaluator
+        const enhancedRGD = resourceGraphDefinition(rgdWithMetadata);
+        try {
+            // Deploy RGD using DirectDeploymentEngine with readiness checking
+            await deploymentEngine.deployResource(enhancedRGD, {
+                mode: 'direct',
+                namespace: this.namespace,
+                waitForReady: true,
+                timeout: this.factoryOptions.timeout || 60000,
+            });
+            // Wait for the CRD to be created by Kro using DirectDeploymentEngine
+            await this.waitForCRDReadyWithEngine(deploymentEngine);
+        }
+        catch (error) {
+            throw new Error(`Failed to deploy RGD using DirectDeploymentEngine: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    /**
+     * Wait for the CRD to be created by Kro using DirectDeploymentEngine
+     */
+    async waitForCRDReadyWithEngine(deploymentEngine) {
+        const crdName = `${this.schemaDefinition.kind.toLowerCase()}s.kro.run`;
+        // Create Enhanced CRD for readiness checking
+        const crdManifest = {
+            apiVersion: 'apiextensions.k8s.io/v1',
+            kind: 'CustomResourceDefinition',
+            metadata: {
+                name: crdName,
+                // CRDs are cluster-scoped, so no namespace
+            },
+        };
+        const enhancedCRD = kroCustomResourceDefinition(crdManifest);
+        // Use DirectDeploymentEngine to wait for CRD readiness
+        const deployedCRD = {
+            id: crdName,
+            kind: 'CustomResourceDefinition',
+            name: crdName,
+            namespace: '', // CRDs are cluster-scoped
+            manifest: enhancedCRD,
+            status: 'deployed',
+            deployedAt: new Date(),
+        };
+        // This will use the custom readiness evaluator from kroCustomResourceDefinition()
+        await deploymentEngine.waitForResourceReadiness(deployedCRD, {
+            mode: 'direct',
+            namespace: '', // CRDs are cluster-scoped
+            timeout: this.factoryOptions.timeout || 60000,
+        });
+    }
+    /**
+     * Separate static and dynamic status fields
+     */
+    async separateStatusFields() {
+        if (!this.statusMappings) {
+            return { staticFields: {}, dynamicFields: {} };
+        }
+        // Use dynamic import to avoid circular dependencies
+        const { separateStatusFields } = await import('../validation/cel-validator.js');
+        return separateStatusFields(this.statusMappings);
+    }
+    /**
+     * Generate instance name from spec
+     */
+    generateInstanceName(spec) {
+        // Try to extract name from spec - check common name fields
+        if (typeof spec === 'object' && spec !== null) {
+            const specObj = spec;
+            // Check for common name fields in order of preference
+            for (const nameField of ['name', 'appName', 'serviceName', 'resourceName']) {
+                if (nameField in specObj && specObj[nameField]) {
+                    return String(specObj[nameField]);
+                }
+            }
+        }
+        // Generate a unique name
+        return `${this.name}-${Date.now()}`;
+    }
+    /**
+     * Create custom resource instance
+     */
+    createCustomResourceInstance(instanceName, spec) {
+        // The schema definition contains just the version part (e.g., 'v1alpha1')
+        // We need to construct the full API version for the instance (e.g., 'kro.run/v1alpha1')
+        const apiVersion = this.schemaDefinition.apiVersion.includes('/')
+            ? this.schemaDefinition.apiVersion // Already has group prefix
+            : `kro.run/${this.schemaDefinition.apiVersion}`; // Add kro.run group
+        return {
+            apiVersion,
+            kind: this.schemaDefinition.kind,
+            metadata: {
+                name: instanceName,
+                namespace: this.namespace,
+            },
+            spec,
+        };
+    }
+    /**
+     * Create an Enhanced proxy for the instance with mixed static/dynamic hydration
+     */
+    async createEnhancedProxyWithMixedHydration(spec, instanceName) {
+        const hydrationLogger = this.logger.child({ instanceName });
+        // Separate static and dynamic status fields
+        const { staticFields, dynamicFields } = await this.separateStatusFields();
+        // Start with static fields as the base status
+        const status = { ...staticFields };
+        // Create the initial Enhanced proxy
+        // The Enhanced proxy should represent the actual instance, which uses the full API version
+        const instanceApiVersion = this.schemaDefinition.apiVersion.includes('/')
+            ? this.schemaDefinition.apiVersion
+            : `kro.run/${this.schemaDefinition.apiVersion}`;
+        const enhancedProxy = {
+            apiVersion: instanceApiVersion,
+            kind: this.schemaDefinition.kind,
+            spec,
+            status,
+            metadata: {
+                name: instanceName,
+                namespace: this.namespace,
+                labels: {
+                    'typekro.io/factory': this.name,
+                    'typekro.io/mode': this.mode,
+                    'typekro.io/rgd': this.rgdName,
+                },
+                annotations: {
+                    'typekro.io/deployed-at': new Date().toISOString(),
+                    'typekro.io/api-version': instanceApiVersion,
+                    'typekro.io/kind': this.schemaDefinition.kind,
+                },
+            },
+        };
+        // Hydrate dynamic status fields if enabled and there are dynamic fields
+        if (this.factoryOptions.hydrateStatus !== false && Object.keys(dynamicFields).length > 0) {
+            try {
+                const hydratedDynamicFields = await this.hydrateDynamicStatusFields(instanceName, dynamicFields);
+                // Merge dynamic fields with static fields
+                // Dynamic fields from Kro take precedence over static fields with same names
+                const mergedStatus = {
+                    ...staticFields, // Static fields first
+                    ...hydratedDynamicFields, // Dynamic fields from Kro override
+                };
+                // Update the status using object assignment to avoid type issues
+                Object.assign(enhancedProxy.status, mergedStatus);
+            }
+            catch (error) {
+                hydrationLogger.warn('Dynamic status hydration failed', error);
+                // Continue with static fields only if dynamic hydration fails
+            }
+        }
+        return enhancedProxy;
+    }
+    /**
+     * Create an Enhanced proxy for the instance (backward compatibility method)
+     */
+    async createEnhancedProxy(spec, instanceName) {
+        return this.createEnhancedProxyWithMixedHydration(spec, instanceName);
+    }
+    /**
+     * Wait for Kro instance to be ready with Kro-specific logic
+     */
+    async waitForKroInstanceReady(instanceName, timeout) {
+        const startTime = Date.now();
+        const readinessLogger = this.logger.child({ instanceName, rgdName: this.name });
+        while (Date.now() - startTime < timeout) {
+            try {
+                const apiVersion = this.schemaDefinition.apiVersion.includes('/')
+                    ? this.schemaDefinition.apiVersion
+                    : `kro.run/${this.schemaDefinition.apiVersion}`;
+                const k8sApi = this.getKubeConfig().makeApiClient(k8s.KubernetesObjectApi);
+                const response = await k8sApi.read({
+                    apiVersion,
+                    kind: this.schemaDefinition.kind,
+                    metadata: {
+                        name: instanceName,
+                        namespace: this.namespace,
+                    },
+                });
+                const instance = response.body;
+                // Kro-specific readiness logic
+                const status = instance.status;
+                if (!status) {
+                    readinessLogger.debug('No status found yet, continuing to wait', { instanceName });
+                    await new Promise(resolve => setTimeout(resolve, 2000));
+                    continue;
+                }
+                const state = status.state;
+                const conditions = status.conditions || [];
+                const syncedCondition = conditions.find(c => c.type === 'InstanceSynced');
+                // Check if status has fields beyond the basic Kro fields (conditions, state)
+                const statusKeys = Object.keys(status);
+                const basicKroFields = ['conditions', 'state'];
+                const hasCustomStatusFields = statusKeys.some(key => !basicKroFields.includes(key));
+                const isActive = state === 'ACTIVE';
+                const isSynced = syncedCondition?.status === 'True';
+                readinessLogger.debug('Kro instance status check', {
+                    instanceName,
+                    state,
+                    isActive,
+                    isSynced,
+                    hasCustomStatusFields,
+                    statusKeys
+                });
+                // Resource is ready when it's active, synced, and has custom status fields populated
+                if (isActive && isSynced && hasCustomStatusFields) {
+                    readinessLogger.info('Kro instance is ready', { instanceName });
+                    return;
+                }
+                // Check for failure states
+                if (state === 'FAILED') {
+                    const failedCondition = conditions.find(c => c.status === 'False');
+                    const errorMessage = failedCondition?.message || 'Unknown error';
+                    throw new Error(`Kro instance deployment failed: ${errorMessage}`);
+                }
+                readinessLogger.debug('Kro instance not ready yet, continuing to wait', {
+                    instanceName,
+                    state,
+                    isSynced,
+                    hasCustomStatusFields
+                });
+            }
+            catch (error) {
+                const k8sError = error;
+                if (k8sError.statusCode !== 404) {
+                    throw error;
+                }
+                // Instance not found yet, continue waiting
+                readinessLogger.debug('Instance not found yet, continuing to wait', { instanceName });
+            }
+            // Wait before checking again - use shorter intervals for faster response
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+        const elapsed = Date.now() - startTime;
+        throw new Error(`Timeout waiting for Kro instance ${instanceName} to be ready after ${elapsed}ms (timeout: ${timeout}ms). This usually means the Kro controller is not running or the RGD deployment failed. Check Kro controller logs: kubectl logs -n kro-system deployment/kro`);
+    }
+    /**
+     * Hydrate dynamic status fields by evaluating CEL expressions against live Kro resource data
+     */
+    async hydrateDynamicStatusFields(instanceName, dynamicFields) {
+        const dynamicLogger = this.logger.child({ instanceName });
+        // Get the live custom resource to extract dynamic status fields
+        const apiVersion = this.schemaDefinition.apiVersion.includes('/')
+            ? this.schemaDefinition.apiVersion
+            : `kro.run/${this.schemaDefinition.apiVersion}`;
+        const k8sApi = this.getKubeConfig().makeApiClient(k8s.KubernetesObjectApi);
+        const response = await k8sApi.read({
+            apiVersion,
+            kind: this.schemaDefinition.kind,
+            metadata: {
+                name: instanceName,
+                namespace: this.namespace,
+            },
+        });
+        const liveInstance = response.body;
+        if (!liveInstance.status) {
+            dynamicLogger.warn('No status found in live instance, returning empty dynamic fields');
+            return {};
+        }
+        // For now, return the live instance status directly
+        // In a full implementation, this would evaluate CEL expressions in dynamicFields
+        // against the live Kro resource data and return the evaluated results
+        // Extract only the fields that were marked as dynamic
+        const hydratedFields = {};
+        for (const [fieldName, _fieldValue] of Object.entries(dynamicFields)) {
+            if (liveInstance.status[fieldName] !== undefined) {
+                hydratedFields[fieldName] = liveInstance.status[fieldName];
+            }
+        }
+        return hydratedFields;
+    }
+}
+/**
+ * Create a KroResourceFactory instance
+ */
+export function createKroResourceFactory(name, resources, schemaDefinition, statusMappings, options = {}) {
+    return new KroResourceFactoryImpl(name, resources, schemaDefinition, statusMappings, options);
+}
+//# sourceMappingURL=kro-factory.js.map