typekro 0.2.2 → 0.3.1

package/dist/core/expressions/analyzer.js

@@ -0,0 +1,2956 @@
+/**
+ * JavaScript to CEL Expression Analyzer
+ *
+ * This module provides the core functionality for detecting KubernetesRef objects
+ * in JavaScript expressions and converting them to appropriate CEL expressions.
+ *
+ * The analyzer works with TypeKro's magic proxy system where schema.spec.name and
+ * resources.database.status.podIP return KubernetesRef objects at runtime.
+ */
+import * as esprima from 'esprima';
+import * as estraverse from 'estraverse';
+import { containsKubernetesRefs, extractResourceReferences, isKubernetesRef } from '../../utils/type-guards.js';
+import { CEL_EXPRESSION_BRAND, KUBERNETES_REF_BRAND } from '../constants/brands.js';
+import { ConversionError } from '../errors.js';
+import { SourceMapUtils } from './source-map.js';
+import { ExpressionCache } from './cache.js';
+import { handleExpressionWithFactoryPattern } from './factory-pattern-handler.js';
+import { ExpressionTypeValidator, TypeRegistry, TypeSafetyUtils } from './type-safety.js';
+import { CelTypeInferenceEngine } from './type-inference.js';
+import { ResourceReferenceValidator } from './resource-validation.js';
+import { CompileTimeTypeChecker } from './compile-time-validation.js';
+/**
+ * Main analyzer class for JavaScript to CEL expression conversion
+ */
+export class JavaScriptToCelAnalyzer {
+    cache;
+    typeValidator = new ExpressionTypeValidator();
+    enableMetrics;
+    constructor(cacheOptions) {
+        this.cache = new ExpressionCache(cacheOptions);
+        this.enableMetrics = cacheOptions?.enableMetrics ?? true;
+    }
+    typeInferenceEngine = new CelTypeInferenceEngine();
+    resourceValidator = new ResourceReferenceValidator();
+    compileTimeChecker = new CompileTimeTypeChecker();
+    /**
+     * Analyze any expression type and convert to CEL if needed
+     */
+    analyzeExpression(expression, context) {
+        // Handle different expression types
+        if (typeof expression === 'string') {
+            return this.analyzeStringExpression(expression, context);
+        }
+        // Handle KubernetesRef objects directly
+        if (expression && typeof expression === 'object' && expression[KUBERNETES_REF_BRAND]) {
+            return this.analyzeKubernetesRefObject(expression, context);
+        }
+        // Handle other objects
+        if (typeof expression === 'object' && expression !== null) {
+            return this.analyzeObjectExpression(expression, context);
+        }
+        // Handle primitives
+        return this.analyzePrimitiveExpression(expression, context);
+    }
+    /**
+     * Analyze a JavaScript string expression and convert to CEL if it contains KubernetesRef objects
+     */
+    analyzeStringExpression(expression, context) {
+        // Check cache first
+        const cached = this.cache.get(expression, context);
+        if (cached)
+            return cached;
+        try {
+            // Handle modern JavaScript syntax that esprima 4.0.1 doesn't support
+            const preprocessedExpression = this.preprocessModernSyntax(expression);
+            // Parse JavaScript expression to AST with location tracking
+            // Try parsing as expression first, then fall back to wrapping in parentheses
+            let ast;
+            let exprNode;
+            try {
+                // Try parsing as a standalone expression first
+                ast = esprima.parseScript(preprocessedExpression, {
+                    ecmaVersion: 2020,
+                    sourceType: 'script',
+                    loc: true,
+                    range: true
+                });
+                exprNode = ast.body[0];
+                // If it's not an expression statement, we need to wrap it
+                if (exprNode.type !== 'ExpressionStatement') {
+                    throw new Error('Not an expression statement');
+                }
+                exprNode = exprNode.expression;
+            }
+            catch (firstError) {
+                // Fall back to wrapping in parentheses
+                try {
+                    ast = esprima.parseScript(`(${preprocessedExpression})`, {
+                        ecmaVersion: 2020,
+                        sourceType: 'script',
+                        loc: true,
+                        range: true
+                    });
+                    exprNode = ast.body[0].expression;
+                }
+                catch (_secondError) {
+                    // Use the original error message from the first attempt
+                    throw firstError;
+                }
+            }
+            // Create source location from AST
+            const sourceLocation = SourceMapUtils.createSourceLocation(exprNode.loc, expression);
+            // Initialize dependencies array if not provided
+            if (!context.dependencies) {
+                context.dependencies = [];
+            }
+            // Convert to CEL with source tracking (this will extract dependencies through AST analysis)
+            const celExpression = this.convertASTNodeWithSourceTracking(exprNode, context, expression, sourceLocation);
+            // Add source mapping entry
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                const _mappingId = context.sourceMap.addMapping(expression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: SourceMapUtils.determineExpressionType(exprNode.type),
+                    kubernetesRefs: SourceMapUtils.extractKubernetesRefPaths(celExpression.expression),
+                    dependencies: context.dependencies?.map(dep => `${dep.resourceId}.${dep.fieldPath}`) || [],
+                    conversionNotes: [`Converted from ${exprNode.type} AST node`]
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            // Perform type validation and inference if enabled
+            let typeValidation;
+            let inferredType;
+            let resourceValidation;
+            if (context.strictTypeChecking !== false && context.typeRegistry) {
+                const availableTypes = context.typeRegistry.getAvailableTypes();
+                typeValidation = this.typeValidator.validateExpression(expression, availableTypes, context.expectedType);
+                inferredType = typeValidation.resultType;
+                // Also perform CEL type inference
+                const celTypeInference = this.inferCelExpressionType(celExpression, context);
+                if (celTypeInference.success && !inferredType) {
+                    inferredType = celTypeInference.resultType;
+                }
+            }
+            // Validate resource references if enabled
+            if (context.validateResourceReferences !== false && context.dependencies) {
+                resourceValidation = this.validateResourceReferences(context.dependencies, context.availableReferences, context.schemaProxy, context.validationContext);
+            }
+            // Perform compile-time type checking if enabled
+            let compileTimeValidation;
+            if (context.compileTimeTypeChecking !== false && context.compileTimeContext) {
+                compileTimeValidation = this.performCompileTimeValidation(expression, context.compileTimeContext);
+            }
+            // Only treat compile-time and type validation errors as critical
+            // Resource validation errors should be warnings, not critical errors
+            const hasCompileTimeErrors = compileTimeValidation && !compileTimeValidation.valid;
+            const hasTypeValidationErrors = typeValidation && !typeValidation.valid;
+            // Collect only critical validation errors that should affect validity
+            const criticalErrors = [];
+            if (compileTimeValidation?.errors) {
+                criticalErrors.push(...compileTimeValidation.errors);
+            }
+            if (typeValidation?.errors) {
+                criticalErrors.push(...typeValidation.errors);
+            }
+            // Resource validation errors are treated as warnings, not critical errors
+            // Aggregate warnings from all validation results
+            const aggregatedWarnings = [];
+            // Add resource validation warnings and errors (treat errors as warnings)
+            if (resourceValidation) {
+                for (const rv of resourceValidation) {
+                    // Add warnings
+                    for (const warning of rv.warnings) {
+                        const warningObj = {
+                            message: warning.message,
+                            type: warning.warningType
+                        };
+                        if (rv.suggestions.length > 0) {
+                            warningObj.suggestion = rv.suggestions.join('; ');
+                        }
+                        aggregatedWarnings.push(warningObj);
+                    }
+                    // Add errors as warnings (resource validation errors shouldn't fail the entire expression)
+                    if (rv.errors) {
+                        for (const error of rv.errors) {
+                            const warningObj = {
+                                message: error instanceof Error ? error.message : String(error),
+                                type: 'resource_validation'
+                            };
+                            if (rv.suggestions.length > 0) {
+                                warningObj.suggestion = rv.suggestions.join('; ');
+                            }
+                            aggregatedWarnings.push(warningObj);
+                        }
+                    }
+                }
+            }
+            // Add type validation warnings (if any)
+            if (typeValidation?.warnings) {
+                for (const warning of typeValidation.warnings) {
+                    aggregatedWarnings.push({
+                        message: warning.message,
+                        type: 'type_validation'
+                        // No suggestion property for TypeValidationWarning
+                    });
+                }
+            }
+            // Add compile-time validation warnings (if any)
+            if (compileTimeValidation?.warnings) {
+                for (const warning of compileTimeValidation.warnings) {
+                    aggregatedWarnings.push({
+                        message: warning.message,
+                        type: 'compile_time'
+                        // No suggestion property for CompileTimeWarning
+                    });
+                }
+            }
+            const result = {
+                valid: celExpression !== null && !hasCompileTimeErrors && !hasTypeValidationErrors,
+                celExpression,
+                dependencies: context.dependencies || [],
+                sourceMap: sourceMapEntries,
+                errors: criticalErrors,
+                requiresConversion: (context.dependencies || []).length > 0, // Only requires conversion if there are KubernetesRef dependencies
+                typeValidation,
+                inferredType,
+                resourceValidation,
+                compileTimeValidation,
+                warnings: aggregatedWarnings
+            };
+            // Cache the result
+            this.cache.set(expression, context, result);
+            return result;
+        }
+        catch (error) {
+            // If parsing fails, try to handle it as a special case
+            const specialCaseResult = this.handleSpecialCases(expression, context);
+            if (specialCaseResult) {
+                // Only cache successful special case results
+                if (specialCaseResult.valid) {
+                    this.cache.set(expression, context, specialCaseResult);
+                }
+                return specialCaseResult;
+            }
+            // Create detailed error with source location
+            const sourceLocation = { line: 1, column: 1, length: expression.length };
+            const conversionError = ConversionError.forParsingFailure(expression, error instanceof Error ? error.message : String(error), sourceLocation, error instanceof Error ? error : undefined);
+            const errorResult = {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [conversionError],
+                requiresConversion: false,
+                warnings: []
+            };
+            // Don't cache error results to allow retry
+            return errorResult;
+        }
+    }
+    /**
+     * Analyze a KubernetesRef object directly
+     */
+    analyzeKubernetesRefObject(ref, context) {
+        // Use the proper CEL path format
+        const resourceId = ref.resourceId === '__schema__' ? 'schema' : ref.resourceId;
+        const celPath = `${resourceId}.${ref.fieldPath}`;
+        // Add to dependencies
+        if (!context.dependencies) {
+            context.dependencies = [];
+        }
+        context.dependencies.push(ref);
+        return {
+            valid: true,
+            celExpression: {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: celPath,
+                _type: ref._type
+            },
+            dependencies: [ref],
+            sourceMap: [],
+            errors: [],
+            warnings: [],
+            requiresConversion: true
+        };
+    }
+    /**
+     * Analyze object expression by examining its structure
+     */
+    analyzeObjectExpression(obj, context) {
+        const kubernetesRefs = [];
+        // Recursively examine object properties for KubernetesRef objects
+        this.extractKubernetesRefsFromObject(obj, kubernetesRefs, '');
+        // Add to dependencies
+        if (!context.dependencies) {
+            context.dependencies = [];
+        }
+        context.dependencies.push(...kubernetesRefs);
+        return {
+            valid: true,
+            celExpression: null, // Objects don't convert to single CEL expressions
+            dependencies: kubernetesRefs,
+            sourceMap: [],
+            errors: [],
+            warnings: [],
+            requiresConversion: kubernetesRefs.length > 0
+        };
+    }
+    /**
+     * Analyze primitive expression (no KubernetesRef objects)
+     */
+    analyzePrimitiveExpression(_value, _context) {
+        return {
+            valid: true,
+            celExpression: null,
+            dependencies: [],
+            sourceMap: [],
+            errors: [],
+            warnings: [],
+            requiresConversion: false
+        };
+    }
+    /**
+     * Extract KubernetesRef objects from object structure
+     */
+    extractKubernetesRefsFromObject(obj, refs, path) {
+        if (!obj || typeof obj !== 'object')
+            return;
+        // Check if this object is a KubernetesRef
+        if (obj[KUBERNETES_REF_BRAND]) {
+            refs.push(obj);
+            return;
+        }
+        // Recursively check properties
+        for (const [key, value] of Object.entries(obj)) {
+            const newPath = path ? `${path}.${key}` : key;
+            this.extractKubernetesRefsFromObject(value, refs, newPath);
+        }
+    }
+    /**
+     * NEW: Analyze expressions that may contain KubernetesRef objects from magic proxy system
+     * This is the key method that detects when JavaScript expressions contain KubernetesRef objects
+     */
+    analyzeExpressionWithRefs(expression, // Could be a JavaScript expression or contain KubernetesRef objects
+    context) {
+        try {
+            // First check if this is a static value (no KubernetesRef objects)
+            if (this.isStaticValue(expression)) {
+                // Static values don't need conversion - preserve them as-is for performance
+                return this.createStaticValueResult(expression);
+            }
+            // Check if the expression contains KubernetesRef objects
+            if (!containsKubernetesRefs(expression)) {
+                // No KubernetesRef objects found - return as-is (no conversion needed)
+                return this.createStaticValueResult(expression);
+            }
+            // Expression contains KubernetesRef objects - needs conversion
+            if (typeof expression === 'string') {
+                // String expression - parse and convert
+                return this.analyzeExpression(expression, context);
+            }
+            if (typeof expression === 'function') {
+                // Function expression - analyze function body
+                return this.analyzeFunction(expression, context);
+            }
+            // Direct KubernetesRef object
+            if (isKubernetesRef(expression)) {
+                return this.convertKubernetesRefToResult(expression, context);
+            }
+            // Template literal or complex expression
+            if (this.isTemplateLiteral(expression)) {
+                return this.analyzeTemplateLiteral(expression, context);
+            }
+            // Complex object/array containing KubernetesRef objects
+            return this.analyzeComplexValue(expression, context);
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(`Failed to analyze expression with refs: ${error instanceof Error ? error.message : String(error)}`, String(expression), 'javascript')],
+                requiresConversion: false,
+                warnings: []
+            };
+        }
+    }
+    /**
+     * Convert an AST node to CEL expression
+     */
+    convertASTNode(node, context) {
+        switch (node.type) {
+            case 'BinaryExpression':
+                return this.convertBinaryExpression(node, context);
+            case 'MemberExpression':
+                return this.convertMemberExpression(node, context);
+            case 'ConditionalExpression':
+                return this.convertConditionalExpression(node, context);
+            case 'LogicalExpression':
+                return this.convertLogicalExpression(node, context);
+            case 'ChainExpression':
+                return this.convertOptionalChaining(node, context);
+            case 'TemplateLiteral':
+                return this.convertTemplateLiteral(node, context);
+            case 'Literal':
+                return this.convertLiteral(node, context);
+            case 'CallExpression':
+                return this.convertCallExpression(node, context);
+            case 'ArrayExpression':
+                return this.convertArrayExpression(node, context);
+            case 'Identifier':
+                return this.convertIdentifier(node, context);
+            case 'UnaryExpression':
+                return this.convertUnaryExpression(node, context);
+            default:
+                throw new Error(`Unsupported expression type: ${node.type}`);
+        }
+    }
+    /**
+     * Convert an AST node to CEL expression with source location tracking
+     */
+    convertASTNodeWithSourceTracking(node, context, originalExpression, sourceLocation) {
+        try {
+            const celExpression = this.convertASTNode(node, context);
+            // Add source mapping if builder is available
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(originalExpression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: SourceMapUtils.determineExpressionType(node.type),
+                    kubernetesRefs: SourceMapUtils.extractKubernetesRefPaths(celExpression.expression),
+                    dependencies: context.dependencies?.map(dep => `${dep.resourceId}.${dep.fieldPath}`) || [],
+                    conversionNotes: [`Converted ${node.type} at line ${sourceLocation.line}, column ${sourceLocation.column}`]
+                });
+            }
+            return celExpression;
+        }
+        catch (_error) {
+            // Create detailed conversion error with source location
+            const conversionError = ConversionError.forUnsupportedSyntax(originalExpression, node.type, sourceLocation, [`The ${node.type} syntax is not supported in this context`]);
+            throw conversionError;
+        }
+    }
+    /**
+     * Analyze a function for JavaScript expressions containing KubernetesRef objects
+     */
+    analyzeFunction(fn, _context) {
+        try {
+            // Parse function to AST
+            const ast = esprima.parseScript(fn.toString());
+            // Find return statement
+            const returnStatement = this.findReturnStatement(ast);
+            if (!returnStatement) {
+                throw new Error('Function must have a return statement for analysis');
+            }
+            // For now, return a placeholder result
+            return {
+                valid: false,
+                celExpression: {
+                    expression: '/* TODO: Analyze function body */',
+                    _type: undefined
+                },
+                dependencies: [],
+                sourceMap: [],
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(error instanceof Error ? error.message : String(error), fn.toString(), 'function-call')],
+                warnings: [],
+                requiresConversion: false
+            };
+        }
+    }
+    /**
+     * Convert a single KubernetesRef to a conversion result
+     */
+    convertKubernetesRefToResult(ref, context) {
+        try {
+            // Use the dedicated KubernetesRef to CEL conversion method
+            const celExpression = this.convertKubernetesRefToCel(ref, context);
+            const originalExpression = `${ref.resourceId}.${ref.fieldPath}`;
+            // Create source location for the KubernetesRef
+            const sourceLocation = {
+                line: 1,
+                column: 1,
+                length: originalExpression.length
+            };
+            // Add source mapping
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(originalExpression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: 'member-access',
+                    kubernetesRefs: [originalExpression],
+                    dependencies: [`${ref.resourceId}.${ref.fieldPath}`],
+                    conversionNotes: ['Direct KubernetesRef to CEL conversion']
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            return {
+                valid: true,
+                celExpression,
+                dependencies: [ref],
+                sourceMap: sourceMapEntries,
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (_error) {
+            const originalExpression = `${ref.resourceId}.${ref.fieldPath}`;
+            const sourceLocation = { line: 1, column: 1, length: originalExpression.length };
+            const conversionError = ConversionError.forKubernetesRefResolution(originalExpression, originalExpression, Object.keys(context.availableReferences || {}), sourceLocation);
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [ref],
+                sourceMap: [],
+                errors: [conversionError],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Analyze complex values (objects/arrays) that may contain KubernetesRef objects
+     */
+    analyzeComplexValue(value, context) {
+        const dependencies = [];
+        const errors = [];
+        try {
+            // Recursively find all KubernetesRef objects
+            this.extractKubernetesRefs(value, dependencies);
+            if (dependencies.length === 0) {
+                return {
+                    valid: false,
+                    celExpression: null,
+                    dependencies: [],
+                    sourceMap: [],
+                    errors: [],
+                    warnings: [],
+                    requiresConversion: false
+                };
+            }
+            // For complex values, we'll need to analyze the structure
+            // This is a placeholder implementation - will be expanded in later tasks
+            const originalExpression = JSON.stringify(value, null, 2);
+            const celExpression = {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: `/* TODO: Convert complex value with ${dependencies.length} references */`,
+                _type: undefined
+            };
+            // Create source location for the complex value
+            const sourceLocation = {
+                line: 1,
+                column: 1,
+                length: originalExpression.length
+            };
+            // Add source mapping
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(originalExpression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: 'javascript',
+                    kubernetesRefs: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    dependencies: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    conversionNotes: [`Complex value with ${dependencies.length} KubernetesRef objects`]
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            return {
+                valid: true,
+                celExpression,
+                dependencies,
+                sourceMap: sourceMapEntries,
+                errors,
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            const originalExpression = JSON.stringify(value);
+            const sourceLocation = { line: 1, column: 1, length: originalExpression.length };
+            const conversionError = ConversionError.forParsingFailure(originalExpression, error instanceof Error ? error.message : String(error), sourceLocation, error instanceof Error ? error : undefined);
+            errors.push(conversionError);
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies,
+                sourceMap: [],
+                errors,
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Generate CEL expression from KubernetesRef based on context
+     * This handles the core KubernetesRef to CEL field path conversion (resourceId.fieldPath)
+     */
+    generateCelFromKubernetesRef(ref, context) {
+        // Validate the KubernetesRef
+        if (!ref.resourceId || !ref.fieldPath) {
+            throw new Error(`Invalid KubernetesRef: missing resourceId or fieldPath`);
+        }
+        // Generate appropriate CEL expression based on factory type and resource type
+        if (context.factoryType === 'kro') {
+            // For Kro factory, generate CEL expressions for runtime evaluation by Kro controller
+            if (ref.resourceId === '__schema__') {
+                // Schema references: schema.spec.name, schema.status.ready
+                return `schema.${ref.fieldPath}`;
+            }
+            else {
+                // Resource references: resources.database.status.podIP
+                return `resources.${ref.resourceId}.${ref.fieldPath}`;
+            }
+        }
+        else {
+            // For direct factory, generate CEL expressions that will be resolved at deployment time
+            // The direct factory will resolve these before deployment
+            if (ref.resourceId === '__schema__') {
+                // Schema references are resolved from the schema proxy
+                return `schema.${ref.fieldPath}`;
+            }
+            else {
+                // Resource references are resolved from the available resources
+                return `resources.${ref.resourceId}.${ref.fieldPath}`;
+            }
+        }
+    }
+    /**
+     * Convert a KubernetesRef directly to a CEL expression
+     * This is the main method for KubernetesRef to CEL field path conversion
+     */
+    convertKubernetesRefToCel(ref, context) {
+        try {
+            // Validate KubernetesRef types if type checking is enabled
+            if (context.strictTypeChecking !== false && context.typeRegistry) {
+                const validation = this.typeValidator.validateKubernetesRef(ref, context.availableReferences, context.schemaProxy);
+                if (!validation.valid) {
+                    throw new ConversionError(`KubernetesRef type validation failed: ${validation.errors.map(e => e.message).join(', ')}`, `${ref.resourceId}.${ref.fieldPath}`, 'member-access');
+                }
+            }
+            const expression = this.generateCelFromKubernetesRef(ref, context);
+            // Track this KubernetesRef as a dependency
+            if (context.dependencies) {
+                context.dependencies.push(ref);
+            }
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: ref._type
+            };
+        }
+        catch (error) {
+            throw new ConversionError(`Failed to convert KubernetesRef to CEL: ${error instanceof Error ? error.message : String(error)}`, `${ref.resourceId}.${ref.fieldPath}`, 'member-access');
+        }
+    }
+    /**
+     * Find return statement in AST
+     */
+    findReturnStatement(ast) {
+        let returnStatement = null;
+        estraverse.traverse(ast, {
+            enter: (node) => {
+                if (node.type === 'ReturnStatement') {
+                    returnStatement = node;
+                    return estraverse.VisitorOption.Break;
+                }
+                return undefined; // Continue traversal
+            }
+        });
+        return returnStatement;
+    }
+    /**
+     * Check if a value is a template literal expression
+     * This checks for JavaScript template literal syntax in runtime values
+     */
+    isTemplateLiteral(value) {
+        // Check if it's a string that looks like a template literal
+        if (typeof value === 'string') {
+            // Look for template literal patterns like `text ${expression} more text`
+            return value.includes('${') && value.includes('}');
+        }
+        // Check if it's an object that represents a template literal structure
+        if (value && typeof value === 'object' && value.type === 'TemplateLiteral') {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Analyze template literal expressions containing KubernetesRef objects
+     * This handles runtime template literal values that contain KubernetesRef interpolations
+     */
+    analyzeTemplateLiteral(expression, context) {
+        try {
+            const dependencies = extractResourceReferences(expression);
+            const originalExpression = String(expression);
+            let celExpression;
+            if (typeof expression === 'string') {
+                // Handle string-based template literals
+                // For now, preserve the template literal structure
+                celExpression = {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: expression, // Keep the ${} syntax for CEL
+                    _type: 'string'
+                };
+            }
+            else {
+                // Handle structured template literal objects
+                // This would be used when we have parsed template literal AST nodes
+                celExpression = {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: '/* Complex template literal */',
+                    _type: 'string'
+                };
+            }
+            // Create source location for the template literal
+            const sourceLocation = {
+                line: 1,
+                column: 1,
+                length: originalExpression.length
+            };
+            // Add source mapping
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(originalExpression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: 'template-literal',
+                    kubernetesRefs: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    dependencies: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    conversionNotes: ['Template literal with KubernetesRef interpolations']
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            return {
+                valid: true,
+                celExpression,
+                dependencies,
+                sourceMap: sourceMapEntries,
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            const originalExpression = String(expression);
+            const sourceLocation = { line: 1, column: 1, length: originalExpression.length };
+            const conversionError = ConversionError.forTemplateLiteral(originalExpression, [originalExpression], 0, sourceLocation, error instanceof Error ? error : undefined);
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [conversionError],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Extract all KubernetesRef objects from a complex value
+     */
+    extractKubernetesRefs(value, refs) {
+        const extractedRefs = extractResourceReferences(value);
+        refs.push(...extractedRefs);
+    }
+    /**
+     * Handle special cases for expressions that can't be parsed normally
+     */
+    handleSpecialCases(expression, context) {
+        // Handle expressions with both optional chaining and nullish coalescing
+        if (expression.includes('?.') && expression.includes('??')) {
+            return this.handleMixedOptionalAndNullishExpression(expression, context);
+        }
+        // Handle optional chaining expressions
+        if (expression.includes('?.')) {
+            return this.handleOptionalChainingExpression(expression, context);
+        }
+        // Handle nullish coalescing expressions
+        if (expression.includes('??')) {
+            return this.handleNullishCoalescingExpression(expression, context);
+        }
+        // Handle simple resource references that might not parse as valid JavaScript
+        if (expression.match(/^[a-zA-Z_][a-zA-Z0-9_]*(\.[a-zA-Z_][a-zA-Z0-9_]*)*$/)) {
+            // This looks like a simple property access path
+            try {
+                // Initialize dependencies array if not provided
+                if (!context.dependencies) {
+                    context.dependencies = [];
+                }
+                // Extract dependencies from the expression
+                this.extractDependenciesFromExpression(expression, context);
+                const celExpression = {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: expression,
+                    _type: undefined
+                };
+                const sourceLocation = { line: 1, column: 1, length: expression.length };
+                const sourceMapEntries = [];
+                if (context.sourceMap) {
+                    context.sourceMap.addMapping(expression, expression, sourceLocation, context.type, {
+                        expressionType: 'member-access',
+                        kubernetesRefs: this.extractResourceReferencesFromExpression(expression),
+                        dependencies: context.dependencies?.map(dep => `${dep.resourceId}.${dep.fieldPath}`) || [],
+                        conversionNotes: ['Simple property access path']
+                    });
+                    sourceMapEntries.push(...context.sourceMap.getEntries());
+                }
+                // Perform resource validation if enabled
+                let resourceValidation;
+                if (context.validateResourceReferences !== false && context.dependencies && context.dependencies.length > 0) {
+                    resourceValidation = this.validateResourceReferences(context.dependencies, context.availableReferences, context.schemaProxy, context.validationContext);
+                }
+                // Extract errors from resource validation
+                const errors = [];
+                if (resourceValidation) {
+                    for (const validation of resourceValidation) {
+                        for (const error of validation.errors) {
+                            errors.push(new ConversionError(error.message, expression, 'member-access'));
+                        }
+                    }
+                }
+                return {
+                    valid: errors.length === 0,
+                    celExpression,
+                    dependencies: context.dependencies || [],
+                    sourceMap: sourceMapEntries,
+                    errors,
+                    warnings: [],
+                    requiresConversion: true,
+                    resourceValidation
+                };
+            }
+            catch (_error) {
+                // Fall through to return null
+            }
+        }
+        return null;
+    }
+    /**
+     * Handle optional chaining expressions that can't be parsed by esprima
+     */
+    handleOptionalChainingExpression(expression, context) {
+        try {
+            // First, validate that the expression is syntactically valid JavaScript
+            // even if esprima doesn't support optional chaining
+            // We'll do a basic syntax check by removing the optional chaining and parsing
+            const withoutOptionalChaining = expression
+                .replace(/\?\.\[/g, '[') // Replace ?.[  with [
+                .replace(/\?\.\(/g, '(') // Replace ?.( with (
+                .replace(/\?\./g, '.'); // Replace ?. with .
+            try {
+                // Try to parse the expression without optional chaining to validate basic syntax
+                esprima.parseScript(`(${withoutOptionalChaining})`);
+            }
+            catch (syntaxError) {
+                // If it fails to parse even without optional chaining, it has syntax errors
+                throw new ConversionError(`Invalid JavaScript syntax in optional chaining expression: ${syntaxError instanceof Error ? syntaxError.message : String(syntaxError)}`, expression, 'optional-chaining');
+            }
+            // Convert optional chaining to CEL-compatible syntax
+            // deployment?.status?.readyReplicas -> deployment?.status?.readyReplicas
+            const celExpression = {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: expression, // Keep the ?. syntax as CEL supports it
+                _type: undefined
+            };
+            const sourceLocation = { line: 1, column: 1, length: expression.length };
+            const sourceMapEntries = [];
+            // Extract dependencies from the optional chaining expression
+            const dependencies = this.extractDependenciesFromExpressionString(expression, context);
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(expression, expression, sourceLocation, context.type, {
+                    expressionType: 'optional-chaining',
+                    kubernetesRefs: this.extractResourceReferencesFromExpression(expression),
+                    dependencies: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    conversionNotes: ['Optional chaining expression']
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            return {
+                valid: true,
+                celExpression,
+                dependencies,
+                sourceMap: sourceMapEntries,
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(`Failed to handle optional chaining: ${error instanceof Error ? error.message : String(error)}`, expression, 'optional-chaining')],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Handle expressions with both optional chaining and nullish coalescing
+     */
+    handleMixedOptionalAndNullishExpression(expression, context) {
+        try {
+            // For mixed expressions, we'll convert them to a CEL expression that handles both
+            // Optional chaining and nullish coalescing together
+            // Example: deployment.status?.readyReplicas ?? deployment.spec?.replicas ?? 1
+            // Becomes: deployment.status?.readyReplicas != null ? deployment.status?.readyReplicas : (deployment.spec?.replicas != null ? deployment.spec?.replicas : 1)
+            // Split by nullish coalescing operator
+            const parts = expression.split('??').map(part => part.trim());
+            if (parts.length < 2) {
+                throw new Error('Invalid mixed expression');
+            }
+            // Build nested conditional expression from right to left
+            let celExpression = parts[parts.length - 1] || ''; // Start with the last part (fallback)
+            for (let i = parts.length - 2; i >= 0; i--) {
+                const part = parts[i];
+                celExpression = `${part} != null ? ${part} : ${celExpression}`;
+            }
+            const result = {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: celExpression,
+                _type: undefined
+            };
+            // Extract dependencies from the mixed expression
+            const dependencies = this.extractDependenciesFromExpressionString(expression, context);
+            const sourceLocation = { line: 1, column: 1, length: expression.length };
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(expression, result.expression, sourceLocation, context.type, {
+                    expressionType: 'optional-chaining',
+                    kubernetesRefs: this.extractResourceReferencesFromExpression(expression),
+                    dependencies: dependencies.map(dep => `${dep.resourceId}.${dep.fieldPath}`),
+                    conversionNotes: ['Mixed optional chaining and nullish coalescing converted to nested conditionals']
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            return {
+                valid: true,
+                celExpression: result,
+                dependencies,
+                sourceMap: sourceMapEntries,
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(`Failed to handle mixed optional chaining and nullish coalescing: ${error instanceof Error ? error.message : String(error)}`, expression, 'optional-chaining')],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Handle nullish coalescing expressions that can't be parsed by esprima
+     */
+    handleNullishCoalescingExpression(expression, context) {
+        try {
+            // Convert nullish coalescing to CEL-compatible syntax
+            // deployment.status.readyReplicas ?? 0 -> deployment.status.readyReplicas != null ? deployment.status.readyReplicas : 0
+            const parts = expression.split('??').map(part => part.trim());
+            if (parts.length !== 2) {
+                throw new Error('Invalid nullish coalescing expression');
+            }
+            const [left, right] = parts;
+            const celExpression = {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: `${left} != null ? ${left} : ${right}`,
+                _type: undefined
+            };
+            const sourceLocation = { line: 1, column: 1, length: expression.length };
+            const sourceMapEntries = [];
+            if (context.sourceMap) {
+                context.sourceMap.addMapping(expression, celExpression.expression, sourceLocation, context.type, {
+                    expressionType: 'nullish-coalescing',
+                    kubernetesRefs: this.extractResourceReferencesFromExpression(expression),
+                    dependencies: this.extractResourceReferencesFromExpression(expression),
+                    conversionNotes: ['Nullish coalescing converted to conditional']
+                });
+                sourceMapEntries.push(...context.sourceMap.getEntries());
+            }
+            // Extract dependencies from the nullish coalescing expression
+            const dependencies = this.extractDependenciesFromExpressionString(expression, context);
+            return {
+                valid: true,
+                celExpression,
+                dependencies,
+                sourceMap: sourceMapEntries,
+                errors: [],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(`Failed to handle nullish coalescing: ${error instanceof Error ? error.message : String(error)}`, expression, 'nullish-coalescing')],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Extract resource references from expression string
+     */
+    extractResourceReferencesFromExpression(expression) {
+        const refs = [];
+        // Look for patterns like deployment.status.readyReplicas or service?.status?.loadBalancer
+        const resourcePattern = /([a-zA-Z_][a-zA-Z0-9_]*)\??\.([a-zA-Z_][a-zA-Z0-9_]*(?:\??\.?[a-zA-Z_][a-zA-Z0-9_]*)*)/g;
+        let match = resourcePattern.exec(expression);
+        while (match !== null) {
+            refs.push(match[0].replace(/\?/g, '')); // Remove optional chaining operators for reference tracking
+            match = resourcePattern.exec(expression);
+        }
+        return refs;
+    }
+    /**
+     * Check if an expression is a resource reference
+     */
+    isResourceReference(expression) {
+        // Check for explicit resource/schema prefixes
+        if (expression.includes('resources.') || expression.includes('schema.')) {
+            return true;
+        }
+        // Check if it starts with a known resource name (for direct references like deployment.status.field)
+        const parts = expression.split('.');
+        if (parts.length >= 2) {
+            const resourceName = parts[0];
+            // This is a heuristic - if it looks like a resource reference pattern
+            return !!(resourceName && /^[a-zA-Z][a-zA-Z0-9-]*$/.test(resourceName) &&
+                (parts[1] === 'status' || parts[1] === 'spec' || parts[1] === 'metadata'));
+        }
+        return false;
+    }
+    /**
+     * Setup type registry from analysis context
+     */
+    setupTypeRegistry(context) {
+        const registry = new TypeRegistry();
+        // Register resource types
+        for (const [resourceId, resource] of Object.entries(context.availableReferences)) {
+            const resourceType = TypeSafetyUtils.fromEnhancedType(resource);
+            registry.registerResourceType(resourceId, resourceType);
+        }
+        // Register basic types
+        registry.registerType('string', { typeName: 'string', optional: false, nullable: false });
+        registry.registerType('number', { typeName: 'number', optional: false, nullable: false });
+        registry.registerType('boolean', { typeName: 'boolean', optional: false, nullable: false });
+        registry.registerType('null', { typeName: 'null', optional: false, nullable: true });
+        registry.registerType('undefined', { typeName: 'undefined', optional: true, nullable: false });
+        return registry;
+    }
+    /**
+     * Validate expression compatibility with target context
+     */
+    validateExpressionCompatibility(expression, context) {
+        const registry = context.typeRegistry || this.setupTypeRegistry(context);
+        const availableTypes = registry.getAvailableTypes();
+        return this.typeValidator.validateExpression(expression, availableTypes, context.expectedType);
+    }
+    /**
+     * Infer the type of a CEL expression
+     */
+    inferCelExpressionType(celExpression, context) {
+        const inferenceContext = {
+            availableResources: context.availableReferences,
+            ...(context.schemaProxy && { schemaProxy: context.schemaProxy }),
+            factoryType: context.factoryType
+        };
+        return this.typeInferenceEngine.inferType(celExpression, inferenceContext);
+    }
+    /**
+     * Infer types for multiple CEL expressions
+     */
+    inferCelExpressionTypes(celExpressions, context) {
+        const inferenceContext = {
+            availableResources: context.availableReferences,
+            ...(context.schemaProxy && { schemaProxy: context.schemaProxy }),
+            factoryType: context.factoryType
+        };
+        return this.typeInferenceEngine.inferTypes(celExpressions, inferenceContext);
+    }
+    /**
+     * Validate type compatibility between JavaScript and CEL expressions
+     */
+    validateJavaScriptToCelTypeCompatibility(jsExpression, celExpression, context) {
+        // Get JavaScript expression type
+        const jsValidation = this.validateExpressionCompatibility(jsExpression, context);
+        if (!jsValidation.resultType) {
+            return jsValidation;
+        }
+        // Get CEL expression type
+        const celInference = this.inferCelExpressionType(celExpression, context);
+        if (!celInference.success) {
+            return {
+                valid: false,
+                errors: celInference.errors.map(e => ({
+                    message: e.message,
+                    expression: e.celExpression,
+                    expectedType: { typeName: 'unknown', optional: false, nullable: false },
+                    actualType: { typeName: 'unknown', optional: false, nullable: false }
+                })),
+                warnings: [],
+                suggestions: []
+            };
+        }
+        // Validate compatibility
+        return this.typeInferenceEngine.validateTypeCompatibility(jsValidation.resultType, celInference.resultType);
+    }
+    /**
+     * Validate resource references in KubernetesRef objects
+     */
+    validateResourceReferences(refs, availableResources, schemaProxy, validationContext) {
+        return this.resourceValidator.validateKubernetesRefs(refs, availableResources, schemaProxy, validationContext);
+    }
+    /**
+     * Validate a single resource reference
+     */
+    validateResourceReference(ref, availableResources, schemaProxy, validationContext) {
+        return this.resourceValidator.validateKubernetesRef(ref, availableResources, schemaProxy, validationContext);
+    }
+    /**
+     * Validate a reference chain for type safety and circular dependencies
+     */
+    validateReferenceChain(refs, availableResources, schemaProxy) {
+        return this.resourceValidator.validateReferenceChain(refs, availableResources, schemaProxy);
+    }
+    /**
+     * Get comprehensive validation report for an expression
+     */
+    getValidationReport(expression, context) {
+        const conversionResult = this.analyzeExpression(expression, context);
+        return {
+            expression,
+            conversionResult,
+            ...(conversionResult.typeValidation && { typeValidation: conversionResult.typeValidation }),
+            ...(conversionResult.resourceValidation && { resourceValidation: conversionResult.resourceValidation }),
+            summary: this.createValidationSummary(conversionResult)
+        };
+    }
+    /**
+     * Perform compile-time type checking
+     */
+    performCompileTimeValidation(expression, context) {
+        return this.compileTimeChecker.validateExpressionCompatibility(expression, context);
+    }
+    /**
+     * Validate compile-time compatibility for multiple expressions
+     */
+    performCompileTimeValidationBatch(expressions, context) {
+        return this.compileTimeChecker.validateExpressionsCompatibility(expressions, context);
+    }
+    /**
+     * Validate KubernetesRef compile-time compatibility
+     */
+    validateKubernetesRefCompileTimeCompatibility(ref, context) {
+        if (!context.compileTimeContext) {
+            throw new Error('Compile-time context required for KubernetesRef validation');
+        }
+        const usageContext = {
+            availableResources: context.availableReferences,
+            ...(context.schemaProxy && { schemaProxy: context.schemaProxy }),
+            usageType: 'property-access',
+            ...(context.expectedType && {
+                expectedResultType: {
+                    typeName: context.expectedType.typeName,
+                    isUnion: false,
+                    isGeneric: false,
+                    optional: context.expectedType.optional,
+                    nullable: context.expectedType.nullable,
+                    undefinable: context.expectedType.optional
+                }
+            })
+        };
+        return this.compileTimeChecker.validateKubernetesRefCompatibility(ref, usageContext, context.compileTimeContext);
+    }
+    /**
+     * Get comprehensive compile-time validation report
+     */
+    getCompileTimeValidationReport(expression, context) {
+        if (!context.compileTimeContext) {
+            return null;
+        }
+        return this.performCompileTimeValidation(expression, context.compileTimeContext);
+    }
+    /**
+     * Create a validation summary from conversion results
+     */
+    createValidationSummary(result) {
+        const totalErrors = result.errors.length +
+            (result.typeValidation?.errors.length || 0) +
+            (result.resourceValidation?.reduce((sum, rv) => sum + rv.errors.length, 0) || 0) +
+            (result.compileTimeValidation?.errors.length || 0);
+        const totalWarnings = (result.typeValidation?.warnings.length || 0) +
+            (result.resourceValidation?.reduce((sum, rv) => sum + rv.warnings.length, 0) || 0) +
+            (result.compileTimeValidation?.warnings.length || 0);
+        return {
+            valid: result.celExpression !== null && totalErrors === 0,
+            totalErrors,
+            totalWarnings,
+            requiresConversion: result.requiresConversion,
+            hasTypeIssues: (result.typeValidation?.errors.length || 0) > 0,
+            hasResourceIssues: (result.resourceValidation?.some(rv => !rv.valid)) || false,
+            hasCompileTimeIssues: (result.compileTimeValidation && !result.compileTimeValidation.valid) || false,
+            confidence: this.calculateOverallConfidence(result)
+        };
+    }
+    /**
+     * Extract dependencies from JavaScript expression string and return them
+     */
+    extractDependenciesFromExpressionString(expression, context) {
+        const dependencies = [];
+        // Look for direct resource references (deployment.status.field)
+        if (context.availableReferences) {
+            for (const [resourceKey, _resource] of Object.entries(context.availableReferences)) {
+                const resourcePattern = new RegExp(`\\b${resourceKey}\\.([a-zA-Z0-9_.?\\[\\]]+)`, 'g');
+                const matches = expression.match(resourcePattern);
+                if (matches) {
+                    for (const match of matches) {
+                        const fieldPath = match.substring(resourceKey.length + 1)
+                            .replace(/\?\./g, '.') // Remove optional chaining
+                            .replace(/\?\[/g, '['); // Remove optional array access
+                        const ref = {
+                            [KUBERNETES_REF_BRAND]: true,
+                            resourceId: resourceKey,
+                            fieldPath,
+                            _type: this.inferTypeFromFieldPath(fieldPath)
+                        };
+                        // Only add if not already present
+                        if (!dependencies.some(dep => dep.resourceId === resourceKey && dep.fieldPath === fieldPath)) {
+                            dependencies.push(ref);
+                        }
+                    }
+                }
+            }
+        }
+        // Look for schema references (schema.spec.field)
+        const schemaPattern = /\bschema\.[a-zA-Z0-9_.?[\]?]+/g;
+        const schemaMatches = expression.match(schemaPattern);
+        if (schemaMatches) {
+            for (const match of schemaMatches) {
+                const fieldPath = match.replace('schema.', '')
+                    .replace(/\?\./g, '.') // Remove optional chaining
+                    .replace(/\?\[/g, '['); // Remove optional array access
+                const ref = {
+                    [KUBERNETES_REF_BRAND]: true,
+                    resourceId: '__schema__',
+                    fieldPath,
+                    _type: this.inferTypeFromFieldPath(fieldPath)
+                };
+                // Only add if not already present
+                if (!dependencies.some(dep => dep.resourceId === '__schema__' && dep.fieldPath === fieldPath)) {
+                    dependencies.push(ref);
+                }
+            }
+        }
+        return dependencies;
+    }
+    /**
+     * Extract dependencies from JavaScript expression
+     */
+    extractDependenciesFromExpression(expression, context) {
+        if (!context.dependencies) {
+            context.dependencies = [];
+        }
+        // Look for resource references (resources.name.field)
+        const resourceMatches = expression.match(/resources\.(\w+)\.([a-zA-Z0-9_.]+)/g);
+        if (resourceMatches) {
+            for (const match of resourceMatches) {
+                const parts = match.split('.');
+                if (parts.length >= 3) {
+                    const resourceId = parts[1];
+                    const fieldPath = parts.slice(2).join('.');
+                    const ref = {
+                        [KUBERNETES_REF_BRAND]: true,
+                        resourceId,
+                        fieldPath,
+                        _type: 'unknown'
+                    };
+                    // Only add if not already present
+                    if (!context.dependencies.some(dep => dep.resourceId === resourceId && dep.fieldPath === fieldPath)) {
+                        context.dependencies.push(ref);
+                    }
+                }
+            }
+        }
+        // Look for schema references (schema.spec.field)
+        const schemaMatches = expression.match(/schema\.([a-zA-Z0-9_.]+)/g);
+        if (schemaMatches) {
+            for (const match of schemaMatches) {
+                const fieldPath = match.replace('schema.', '');
+                const ref = {
+                    [KUBERNETES_REF_BRAND]: true,
+                    resourceId: '__schema__',
+                    fieldPath,
+                    _type: 'unknown'
+                };
+                // Only add if not already present
+                if (!context.dependencies.some(dep => dep.resourceId === '__schema__' && dep.fieldPath === fieldPath)) {
+                    context.dependencies.push(ref);
+                }
+            }
+        }
+        // Look for direct resource references with various patterns
+        // This handles patterns like:
+        // - "deployment.status.readyReplicas"
+        // - "deployment.status['readyReplicas']"
+        // - "deployment.status?.readyReplicas"
+        // - "deployment.status.conditions[0].type"
+        const directResourcePatterns = [
+            // Standard dot notation: deployment.status.readyReplicas
+            /\b([a-zA-Z_][a-zA-Z0-9_]*)\.(status|spec|metadata)\.([a-zA-Z0-9_.[\]]+)/g,
+            // Computed property access: deployment.status["readyReplicas"]
+            /\b([a-zA-Z_][a-zA-Z0-9_]*)\.(status|spec|metadata)\["([^"]+)"\]/g,
+            // Computed property access with single quotes: deployment.status['readyReplicas']
+            /\b([a-zA-Z_][a-zA-Z0-9_]*)\.(status|spec|metadata)\['([^']+)'\]/g,
+            // Optional chaining: deployment.status?.readyReplicas
+            /\b([a-zA-Z_][a-zA-Z0-9_]*)\.(status|spec|metadata)\?\?\.([a-zA-Z0-9_.[\]?]+)/g,
+            // Mixed patterns: deployment.status.conditions[0].type
+            /\b([a-zA-Z_][a-zA-Z0-9_]*)\.(status|spec|metadata)\.([a-zA-Z0-9_.[\]?]+)/g
+        ];
+        for (const pattern of directResourcePatterns) {
+            let match;
+            pattern.lastIndex = 0; // Reset regex state
+            match = pattern.exec(expression);
+            while (match !== null) {
+                const fullMatch = match[0];
+                const resourceId = match[1];
+                const baseField = match[2]; // status, spec, or metadata
+                const remainingPath = match[3];
+                let fieldPath = baseField;
+                // Handle different patterns
+                if (remainingPath) {
+                    // For computed property access patterns, the remainingPath is the property name
+                    if (pattern.source.includes('\\["') || pattern.source.includes("\\'")) {
+                        fieldPath = `${baseField}.${remainingPath}`;
+                    }
+                    else {
+                        fieldPath = `${baseField}.${remainingPath}`;
+                    }
+                }
+                else {
+                    // For computed property access, we need to extract the property name differently
+                    const computedMatch = fullMatch.match(/\.(status|spec|metadata)\["([^"]+)"\]/) ||
+                        fullMatch.match(/\.(status|spec|metadata)\['([^']+)'\]/);
+                    if (computedMatch) {
+                        fieldPath = `${computedMatch[1]}.${computedMatch[2]}`;
+                    }
+                }
+                // Clean up field path
+                fieldPath = fieldPath?.replace(/\?\?/g, '').replace(/\?/g, '') || '';
+                fieldPath = fieldPath.replace(/\["([^"]+)"\]/g, '.$1');
+                fieldPath = fieldPath.replace(/\['([^']+)'\]/g, '.$1');
+                fieldPath = fieldPath.replace(/\[(\d+)\]/g, '[$1]'); // Keep array indices
+                // Check if this resource exists in available references or add it anyway
+                const shouldAdd = !context.availableReferences ||
+                    (resourceId ? context.availableReferences[resourceId] : null) ||
+                    true; // Add all for now, let validation handle it later
+                if (shouldAdd) {
+                    const ref = {
+                        [KUBERNETES_REF_BRAND]: true,
+                        resourceId,
+                        fieldPath,
+                        _type: 'unknown'
+                    };
+                    // Only add if not already present
+                    if (!context.dependencies.some(dep => dep.resourceId === resourceId && dep.fieldPath === fieldPath)) {
+                        context.dependencies.push(ref);
+                    }
+                }
+                // Get next match
+                match = pattern.exec(expression);
+            }
+        }
+        // Look for template literal interpolations
+        // This handles patterns like: `http://${service.status.loadBalancer.ingress[0].ip}`
+        const templateLiteralMatches = expression.match(/\$\{([^}]+)\}/g);
+        if (templateLiteralMatches) {
+            for (const match of templateLiteralMatches) {
+                const innerExpression = match.slice(2, -1); // Remove ${ and }
+                // Recursively extract dependencies from the inner expression
+                this.extractDependenciesFromExpression(innerExpression, context);
+            }
+        }
+    }
+    /**
+     * Calculate overall confidence score
+     */
+    calculateOverallConfidence(result) {
+        let confidence = 1.0;
+        // Reduce confidence for errors
+        if (result.errors.length > 0) {
+            confidence *= 0.1;
+        }
+        // Reduce confidence for type validation issues
+        if (result.typeValidation && !result.typeValidation.valid) {
+            confidence *= 0.5;
+        }
+        // Reduce confidence for resource validation issues
+        if (result.resourceValidation) {
+            const invalidResources = result.resourceValidation.filter(rv => !rv.valid).length;
+            if (invalidResources > 0) {
+                confidence *= Math.max(0.1, 1 - (invalidResources * 0.3));
+            }
+        }
+        // Reduce confidence for compile-time validation issues
+        if (result.compileTimeValidation && !result.compileTimeValidation.valid) {
+            confidence *= 0.3;
+        }
+        return Math.max(0, Math.min(1, confidence));
+    }
+    /**
+     * Convert binary expressions (>, <, ==, !=, &&, ||) with KubernetesRef operand handling
+     */
+    convertBinaryExpression(node, context) {
+        // Convert operands with proper precedence handling
+        const left = this.handleComplexExpression(node.left, context, node.operator);
+        const right = this.handleComplexExpression(node.right, context, node.operator);
+        // Map JavaScript operators to CEL operators
+        const operator = this.mapOperatorToCel(node.operator);
+        // Generate CEL expression with proper precedence
+        const leftExpr = this.addParenthesesIfNeeded(left.expression, node.operator, true);
+        const rightExpr = this.addParenthesesIfNeeded(right.expression, node.operator, false);
+        const expression = `${leftExpr} ${operator} ${rightExpr}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert member expressions (object.property, object['property']) and array access (array[0], array[index])
+     */
+    convertMemberExpression(node, context) {
+        // Handle optional member expressions (obj?.prop)
+        if (node.optional) {
+            return this.convertOptionalMemberExpression(node, context);
+        }
+        // Handle computed member access (array[index] or object['key'])
+        if (node.computed) {
+            return this.convertArrayAccess(node, context);
+        }
+        // Check if the object is a complex expression (like a method call result)
+        if (node.object.type === 'CallExpression' || node.object.type === 'MemberExpression' && this.isComplexExpression(node.object)) {
+            // Convert the object expression first
+            const objectExpr = this.convertASTNode(node.object, context);
+            const propertyName = node.property.name;
+            // Create a member access on the result of the complex expression
+            const expression = `${objectExpr.expression}.${propertyName}`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // Try to extract the full member path for simple cases
+        let path;
+        try {
+            path = this.extractMemberPath(node);
+        }
+        catch (_error) {
+            // If path extraction fails, fall back to converting the object and property separately
+            const objectExpr = this.convertASTNode(node.object, context);
+            const propertyName = node.property.name;
+            const expression = `${objectExpr.expression}.${propertyName}`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // Check if this is a resource reference
+        if (context.availableReferences) {
+            for (const [resourceKey, resource] of Object.entries(context.availableReferences)) {
+                if (path.startsWith(`resources.${resourceKey}.`) || path.startsWith(`${resourceKey}.`) || path === resourceKey) {
+                    let fieldPath;
+                    if (path === resourceKey) {
+                        // Direct resource reference
+                        fieldPath = '';
+                    }
+                    else if (path.startsWith('resources.')) {
+                        fieldPath = path.substring(`resources.${resourceKey}.`.length);
+                    }
+                    else {
+                        fieldPath = path.substring(`${resourceKey}.`.length);
+                    }
+                    return this.getResourceFieldReference(resource, resourceKey, fieldPath, context);
+                }
+            }
+        }
+        // Handle schema references
+        if (path.startsWith('schema.')) {
+            return this.getSchemaFieldReference(path, context);
+        }
+        // Handle unknown resources - this should be an error in strict mode
+        const parts = path.split('.');
+        if (parts.length >= 2) {
+            let resourceName;
+            let fieldPath;
+            // Check if this is a resources.* prefixed expression
+            if (parts[0] === 'resources' && parts.length >= 3) {
+                resourceName = parts[1] || ''; // The actual resource name after "resources."
+                fieldPath = parts.slice(2).join('.'); // The field path after the resource name
+            }
+            else {
+                resourceName = parts[0] || '';
+                fieldPath = parts.slice(1).join('.');
+            }
+            // For strict validation contexts, check if resource should be available
+            // For now, we'll be lenient and allow unknown resources with warnings
+            // Create a placeholder KubernetesRef for the unknown resource
+            const unknownRef = {
+                [KUBERNETES_REF_BRAND]: true,
+                resourceId: resourceName,
+                fieldPath: fieldPath,
+                _type: this.inferTypeFromFieldPath(fieldPath)
+            };
+            // Add to dependencies
+            if (context.dependencies) {
+                context.dependencies.push(unknownRef);
+            }
+            // Generate CEL expression for unknown resource
+            const expression = `resources.${resourceName}.${fieldPath}`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        throw new Error(`Unable to resolve member expression: ${path}`);
+    }
+    /**
+     * Convert conditional expressions (condition ? true : false)
+     * Handles ternary operators with proper CEL syntax and KubernetesRef support
+     */
+    convertConditionalExpression(node, context) {
+        const test = this.handleComplexExpression(node.test, context, '?');
+        const consequent = this.handleComplexExpression(node.consequent, context, '?');
+        const alternate = this.handleComplexExpression(node.alternate, context, '?');
+        // Ensure the test condition is properly formatted for CEL
+        let testExpression = test.expression;
+        // If the test is a resource reference or optional chaining, ensure it's properly evaluated as boolean
+        if (this.isResourceReference(testExpression) || testExpression.includes('?')) {
+            // For resource references, we need to check if they exist and are truthy
+            testExpression = this.convertToBooleanTest(testExpression);
+        }
+        // Add parentheses to operands if needed for precedence
+        const testExpr = this.addParenthesesIfNeeded(testExpression, '?', true);
+        const consequentExpr = this.addParenthesesIfNeeded(consequent.expression, '?', false);
+        const alternateExpr = this.addParenthesesIfNeeded(alternate.expression, '?', false);
+        const expression = `${testExpr} ? ${consequentExpr} : ${alternateExpr}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert an expression to a proper boolean test for CEL conditionals
+     */
+    convertToBooleanTest(expression) {
+        // If it's already a comparison or boolean expression, use as-is
+        if (this.isBooleanExpression(expression)) {
+            return expression;
+        }
+        // For resource references and other values, check for truthiness
+        // This handles JavaScript's truthy/falsy semantics in CEL
+        return `${expression} != null && ${expression} != "" && ${expression} != false && ${expression} != 0`;
+    }
+    /**
+     * Check if an expression is already a boolean expression
+     */
+    isBooleanExpression(expression) {
+        // Check for comparison operators
+        const comparisonOperators = ['==', '!=', '>', '<', '>=', '<=', '&&', '||'];
+        return comparisonOperators.some(op => expression.includes(` ${op} `));
+    }
+    /**
+     * Add parentheses to expression if needed for proper precedence
+     */
+    addParenthesesIfNeeded(expression, parentOperator, isLeftOperand) {
+        // If no parent operator, no parentheses needed
+        if (!parentOperator) {
+            return expression;
+        }
+        // Get the precedence of operators in the expression
+        const expressionOperator = this.getMainOperator(expression);
+        if (!expressionOperator) {
+            return expression; // No operator found, likely a simple expression
+        }
+        const parentPrecedence = this.getOperatorPrecedence(parentOperator);
+        const expressionPrecedence = this.getOperatorPrecedence(expressionOperator);
+        // Add parentheses if expression has lower precedence than parent
+        // or if it's a right operand with equal precedence (for left-associative operators)
+        if (expressionPrecedence < parentPrecedence ||
+            (expressionPrecedence === parentPrecedence && !isLeftOperand && this.isLeftAssociative(parentOperator))) {
+            return `(${expression})`;
+        }
+        return expression;
+    }
+    /**
+     * Get the main operator in an expression (the one with lowest precedence)
+     */
+    getMainOperator(expression) {
+        // This is a simplified implementation - in a full parser, we'd need to handle
+        // nested expressions properly. For now, we'll look for operators outside of parentheses.
+        const operators = ['||', '&&', '==', '!=', '<=', '>=', '<', '>', '+', '-', '*', '/', '%'];
+        let depth = 0;
+        let mainOperator = null;
+        let lowestPrecedence = Infinity;
+        for (let i = 0; i < expression.length; i++) {
+            const char = expression[i];
+            if (char === '(') {
+                depth++;
+            }
+            else if (char === ')') {
+                depth--;
+            }
+            else if (depth === 0) {
+                // Check for operators at the top level
+                for (const op of operators) {
+                    if (expression.substring(i, i + op.length) === op) {
+                        const precedence = this.getOperatorPrecedence(op);
+                        if (precedence <= lowestPrecedence) {
+                            lowestPrecedence = precedence;
+                            mainOperator = op;
+                        }
+                        i += op.length - 1; // Skip the operator
+                        break;
+                    }
+                }
+            }
+        }
+        return mainOperator;
+    }
+    /**
+     * Get operator precedence (lower number = lower precedence)
+     */
+    getOperatorPrecedence(operator) {
+        const precedence = {
+            '||': 1,
+            '&&': 2,
+            '==': 3,
+            '!=': 3,
+            '<': 4,
+            '<=': 4,
+            '>': 4,
+            '>=': 4,
+            '+': 5,
+            '-': 5,
+            '*': 6,
+            '/': 6,
+            '%': 6,
+            '??': 1, // Same as ||
+            '?': 0 // Ternary has lowest precedence
+        };
+        return precedence[operator] ?? 10; // Unknown operators get high precedence
+    }
+    /**
+     * Check if an operator is left-associative
+     */
+    isLeftAssociative(operator) {
+        // Most operators are left-associative, ternary is right-associative
+        return operator !== '?';
+    }
+    /**
+     * Handle complex nested expressions with proper precedence
+     */
+    handleComplexExpression(node, context, parentOperator) {
+        const result = this.convertASTNode(node, context);
+        // Add parentheses if needed for precedence
+        const expressionWithParens = this.addParenthesesIfNeeded(result.expression, parentOperator);
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression: expressionWithParens,
+            _type: result._type
+        };
+    }
+    /**
+     * Convert logical expressions (&&, ||, ??)
+     * Handles logical OR fallback conversion (value || default) and nullish coalescing (value ?? default)
+     */
+    convertLogicalExpression(node, context) {
+        const left = this.convertASTNode(node.left, context);
+        const right = this.convertASTNode(node.right, context);
+        if (node.operator === '||') {
+            return this.convertLogicalOrFallback(left, right, context);
+        }
+        if (node.operator === '&&') {
+            return this.convertLogicalAnd(left, right, context);
+        }
+        if (node.operator === '??') {
+            return this.convertNullishCoalescing(left, right, context);
+        }
+        // For other logical operators, use direct mapping
+        const operator = this.mapOperatorToCel(node.operator);
+        const expression = `${left.expression} ${operator} ${right.expression}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert logical OR fallback (value || default) to appropriate CEL conditionals
+     */
+    convertLogicalOrFallback(left, right, _context) {
+        // Add parentheses to operands if they contain lower precedence operators
+        const leftExpr = this.addParenthesesIfNeeded(left.expression, '||', true);
+        const rightExpr = this.addParenthesesIfNeeded(right.expression, '||', false);
+        // For resource references and optional chaining, we can use a simpler null check
+        if (this.isResourceReference(left.expression) || left.expression.includes('?')) {
+            // For resource references, primarily check for null/undefined
+            const expression = `${leftExpr} != null ? ${leftExpr} : ${rightExpr}`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // For general expressions, check for all falsy values
+        // This handles JavaScript's truthy/falsy semantics in CEL
+        const expression = `${leftExpr} != null && ${leftExpr} != "" && ${leftExpr} != false && ${leftExpr} != 0 ? ${leftExpr} : ${rightExpr}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert logical AND (value && other) to CEL conditional
+     */
+    convertLogicalAnd(left, right, _context) {
+        // Add parentheses to operands if they contain lower precedence operators
+        const leftExpr = this.addParenthesesIfNeeded(left.expression, '&&', true);
+        const rightExpr = this.addParenthesesIfNeeded(right.expression, '&&', false);
+        // For resource references, primarily check for null/undefined
+        if (this.isResourceReference(left.expression) || left.expression.includes('?')) {
+            const expression = `${leftExpr} != null ? ${rightExpr} : ${leftExpr}`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // For general expressions, check for all truthy values
+        const expression = `${leftExpr} != null && ${leftExpr} != "" && ${leftExpr} != false && ${leftExpr} != 0 ? ${rightExpr} : ${leftExpr}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert nullish coalescing (value ?? default) to CEL null-checking expressions
+     * Only checks for null and undefined, not other falsy values like || does
+     */
+    convertNullishCoalescing(left, right, _context) {
+        // Add parentheses to operands if they contain lower precedence operators
+        const leftExpr = this.addParenthesesIfNeeded(left.expression, '??', true);
+        const rightExpr = this.addParenthesesIfNeeded(right.expression, '??', false);
+        // Nullish coalescing only checks for null and undefined, not other falsy values
+        // This is more precise than || which checks for all falsy values
+        const expression = `${leftExpr} != null ? ${leftExpr} : ${rightExpr}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Preprocess modern JavaScript syntax for older esprima parser
+     */
+    preprocessModernSyntax(expression) {
+        const processed = expression;
+        // Handle optional chaining (?.) - convert to special handling
+        if (processed.includes('?.')) {
+            // Mark for special handling but don't throw error
+            // Keep as-is for now, let the parser handle it
+        }
+        // Handle nullish coalescing (??) - convert to special handling
+        if (processed.includes('??')) {
+            // Mark for special handling but don't throw error
+            // Keep as-is for now, let the parser handle it
+        }
+        return processed;
+    }
+    /**
+     * Convert optional chaining expressions (obj?.prop?.field) to Kro conditional CEL
+     * Uses Kro's ? operator for null-safe property access
+     */
+    convertOptionalChaining(node, context) {
+        // ChainExpression wraps the actual optional expression
+        const expression = node.expression;
+        if (expression.type === 'MemberExpression' && expression.optional) {
+            return this.convertOptionalMemberExpression(expression, context);
+        }
+        if (expression.type === 'CallExpression' && expression.optional) {
+            return this.convertOptionalCallExpression(expression, context);
+        }
+        // If it's not actually optional, convert the inner expression normally
+        return this.convertASTNode(expression, context);
+    }
+    /**
+     * Convert optional member expressions (obj?.prop, obj?.prop?.field)
+     */
+    convertOptionalMemberExpression(node, context) {
+        // Build the optional chain by recursively processing the object
+        const objectExpr = this.convertASTNode(node.object, context);
+        let propertyAccess;
+        if (node.computed) {
+            // Handle obj?.[key] syntax
+            const property = this.convertASTNode(node.property, context);
+            propertyAccess = `[${property.expression}]`;
+        }
+        else {
+            // Handle obj?.prop syntax
+            propertyAccess = `.${node.property.name}`;
+        }
+        // Use Kro's ? operator for null-safe access
+        // The ? operator in Kro CEL provides null-safe property access
+        const expression = `${objectExpr.expression}?${propertyAccess}`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert optional call expressions (obj?.method?.())
+     */
+    convertOptionalCallExpression(node, context) {
+        // Convert the callee with optional chaining
+        const callee = this.convertASTNode(node.callee, context);
+        // Convert arguments
+        const args = node.arguments.map((arg) => this.convertASTNode(arg, context).expression).join(', ');
+        // Use Kro's ? operator for null-safe method calls
+        const expression = `${callee.expression}?(${args})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert template literals with KubernetesRef interpolation
+     * Handles expressions like `http://${database.status.podIP}:5432/db`
+     */
+    convertTemplateLiteral(node, context) {
+        let result = '';
+        const _dependencies = [];
+        // Process each part of the template literal
+        for (let i = 0; i < node.quasis.length; i++) {
+            // Add the literal string part
+            const literalPart = node.quasis[i].value.cooked;
+            result += literalPart;
+            // Add the interpolated expression if it exists
+            if (i < node.expressions.length) {
+                const expr = this.convertASTNode(node.expressions[i], context);
+                // For template literals, we need to wrap expressions in ${}
+                result += `\${${expr.expression}}`;
+                // Track dependencies from the interpolated expression
+                // Note: We'd need to extract dependencies from the expression
+                // For now, we'll handle this in a future enhancement
+            }
+        }
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression: result,
+            _type: 'string' // Template literals always produce strings
+        };
+    }
+    /**
+     * Convert literal values (strings, numbers, booleans - no KubernetesRef objects)
+     * This preserves literal values exactly as they are, without any KubernetesRef processing
+     */
+    convertLiteral(node, _context) {
+        let literalValue;
+        if (typeof node.value === 'string') {
+            // Preserve string literals with proper quoting for CEL
+            literalValue = `"${node.value.replace(/"/g, '\\"')}"`;
+        }
+        else if (typeof node.value === 'number') {
+            // Preserve numeric literals as-is
+            literalValue = String(node.value);
+        }
+        else if (typeof node.value === 'boolean') {
+            // Preserve boolean literals as-is
+            literalValue = String(node.value);
+        }
+        else if (node.value === null) {
+            // Preserve null literals
+            literalValue = 'null';
+        }
+        else if (node.value === undefined) {
+            // Handle undefined (though this shouldn't appear in valid JS literals)
+            literalValue = 'null';
+        }
+        else {
+            // For any other literal types, convert to string
+            literalValue = `"${String(node.value).replace(/"/g, '\\"')}"`;
+        }
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression: literalValue,
+            _type: typeof node.value
+        };
+    }
+    /**
+     * Convert call expressions (method calls and global functions)
+     */
+    convertCallExpression(node, context) {
+        // Handle global functions and Math methods
+        if (node.callee.type === 'Identifier') {
+            const functionName = node.callee.name;
+            return this.convertGlobalFunction(functionName, node.arguments, context);
+        }
+        // Handle Math.* functions
+        if (node.callee.type === 'MemberExpression' &&
+            node.callee.object.type === 'Identifier' &&
+            node.callee.object.name === 'Math') {
+            const mathMethod = node.callee.property.name;
+            return this.convertMathFunction(mathMethod, node.arguments, context);
+        }
+        // Handle common JavaScript methods that can be converted to CEL
+        if (node.callee.type === 'MemberExpression') {
+            const object = this.convertASTNode(node.callee.object, context);
+            const methodName = node.callee.property.name;
+            switch (methodName) {
+                case 'find':
+                    return this.convertArrayFind(object, node.arguments, context);
+                case 'filter':
+                    return this.convertArrayFilter(object, node.arguments, context);
+                case 'map':
+                    return this.convertArrayMap(object, node.arguments, context);
+                case 'includes':
+                    return this.convertStringIncludes(object, node.arguments, context);
+                case 'some':
+                    return this.convertArraySome(object, node.arguments, context);
+                case 'every':
+                    return this.convertArrayEvery(object, node.arguments, context);
+                case 'startsWith':
+                    return this.convertStringStartsWith(object, node.arguments, context);
+                case 'endsWith':
+                    return this.convertStringEndsWith(object, node.arguments, context);
+                case 'toLowerCase':
+                    return this.convertStringToLowerCase(object, node.arguments, context);
+                case 'toUpperCase':
+                    return this.convertStringToUpperCase(object, node.arguments, context);
+                case 'trim':
+                    return this.convertStringTrim(object, node.arguments, context);
+                case 'substring':
+                    return this.convertStringSubstring(object, node.arguments, context);
+                case 'slice':
+                    return this.convertStringSlice(object, node.arguments, context);
+                case 'split':
+                    return this.convertStringSplit(object, node.arguments, context);
+                case 'join':
+                    return this.convertArrayJoin(object, node.arguments, context);
+                case 'flatMap':
+                    return this.convertArrayFlatMap(object, node.arguments, context);
+                case 'length':
+                    return this.convertLengthProperty(object, context);
+                case 'padStart':
+                    return this.convertStringPadStart(object, node.arguments, context);
+                case 'padEnd':
+                    return this.convertStringPadEnd(object, node.arguments, context);
+                case 'repeat':
+                    return this.convertStringRepeat(object, node.arguments, context);
+                case 'replace':
+                    return this.convertStringReplace(object, node.arguments, context);
+                case 'indexOf':
+                    return this.convertStringIndexOf(object, node.arguments, context);
+                case 'lastIndexOf':
+                    return this.convertStringLastIndexOf(object, node.arguments, context);
+                default:
+                    throw new Error(`Unsupported method call: ${methodName}`);
+            }
+        }
+        throw new Error(`Unsupported call expression`);
+    }
+    /**
+     * Convert global functions like Number(), String(), Boolean()
+     */
+    convertGlobalFunction(functionName, args, context) {
+        const convertedArgs = args.map(arg => this.convertASTNode(arg, context));
+        switch (functionName) {
+            case 'Number':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `double(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'number'
+                    };
+                }
+                break;
+            case 'String':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `string(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'string'
+                    };
+                }
+                break;
+            case 'Boolean':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `bool(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'boolean'
+                    };
+                }
+                break;
+            case 'parseInt':
+                if (args.length >= 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `int(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'number'
+                    };
+                }
+                break;
+            case 'parseFloat':
+                if (args.length >= 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `double(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'number'
+                    };
+                }
+                break;
+        }
+        throw new Error(`Unsupported global function: ${functionName}`);
+    }
+    /**
+     * Convert Math functions like Math.min(), Math.max(), Math.abs()
+     */
+    convertMathFunction(mathMethod, args, context) {
+        const convertedArgs = args.map(arg => this.convertASTNode(arg, context));
+        switch (mathMethod) {
+            case 'min':
+                if (args.length >= 2) {
+                    // CEL doesn't have a direct min function, so we'll use a conditional approach
+                    // For now, we'll use a simple approach for 2 arguments
+                    if (args.length === 2) {
+                        return {
+                            [CEL_EXPRESSION_BRAND]: true,
+                            expression: `${convertedArgs[0]?.expression || 'null'} < ${convertedArgs[1]?.expression || 'null'} ? ${convertedArgs[0]?.expression || 'null'} : ${convertedArgs[1]?.expression || 'null'}`,
+                            _type: 'number'
+                        };
+                    }
+                    else {
+                        // For more than 2 arguments, we'll create a nested conditional
+                        let expression = convertedArgs[0]?.expression || 'null';
+                        for (let i = 1; i < convertedArgs.length; i++) {
+                            expression = `${expression} < ${convertedArgs[i]?.expression || 'null'} ? ${expression} : ${convertedArgs[i]?.expression || 'null'}`;
+                        }
+                        return {
+                            [CEL_EXPRESSION_BRAND]: true,
+                            expression,
+                            _type: 'number'
+                        };
+                    }
+                }
+                break;
+            case 'max':
+                if (args.length >= 2) {
+                    if (args.length === 2) {
+                        return {
+                            [CEL_EXPRESSION_BRAND]: true,
+                            expression: `${convertedArgs[0]?.expression || 'null'} > ${convertedArgs[1]?.expression || 'null'} ? ${convertedArgs[0]?.expression || 'null'} : ${convertedArgs[1]?.expression || 'null'}`,
+                            _type: 'number'
+                        };
+                    }
+                    else {
+                        let expression = convertedArgs[0]?.expression || 'null';
+                        for (let i = 1; i < convertedArgs.length; i++) {
+                            expression = `${expression} > ${convertedArgs[i]?.expression || 'null'} ? ${expression} : ${convertedArgs[i]?.expression || 'null'}`;
+                        }
+                        return {
+                            [CEL_EXPRESSION_BRAND]: true,
+                            expression,
+                            _type: 'number'
+                        };
+                    }
+                }
+                break;
+            case 'abs':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `${convertedArgs[0]?.expression || 'null'} < 0 ? -${convertedArgs[0]?.expression || 'null'} : ${convertedArgs[0]?.expression || 'null'}`,
+                        _type: 'number'
+                    };
+                }
+                break;
+            case 'floor':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `int(${convertedArgs[0]?.expression || 'null'})`,
+                        _type: 'number'
+                    };
+                }
+                break;
+            case 'ceil':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `int(${convertedArgs[0]?.expression || 'null'} + 0.999999)`,
+                        _type: 'number'
+                    };
+                }
+                break;
+            case 'round':
+                if (args.length === 1) {
+                    return {
+                        [CEL_EXPRESSION_BRAND]: true,
+                        expression: `int(${convertedArgs[0]?.expression || 'null'} + 0.5)`,
+                        _type: 'number'
+                    };
+                }
+                break;
+        }
+        throw new Error(`Unsupported Math function: ${mathMethod}`);
+    }
+    /**
+     * Convert unary expressions like !x, +x, -x, !!x
+     */
+    convertUnaryExpression(node, context) {
+        const operand = this.convertASTNode(node.argument, context);
+        switch (node.operator) {
+            case '!':
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: `!${operand.expression}`,
+                    _type: 'boolean'
+                };
+            case '+':
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: `double(${operand.expression})`,
+                    _type: 'number'
+                };
+            case '-':
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: `-${operand.expression}`,
+                    _type: 'number'
+                };
+            case 'typeof':
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression: `type(${operand.expression})`,
+                    _type: 'string'
+                };
+            default:
+                throw new Error(`Unsupported unary operator: ${node.operator}`);
+        }
+    }
+    /**
+     * Convert array expressions
+     */
+    convertArrayExpression(node, context) {
+        const elements = node.elements.map((element) => {
+            if (element === null)
+                return 'null';
+            return this.convertASTNode(element, context).expression;
+        });
+        const expression = `[${elements.join(', ')}]`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert identifier expressions
+     */
+    convertIdentifier(node, context) {
+        // For identifiers, we need to check if they refer to available references
+        const name = node.name;
+        // Check if this is a resource reference
+        if (context.availableReferences?.[name]) {
+            // This is a direct resource reference
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: `resources.${name}`,
+                _type: undefined
+            };
+        }
+        // Check if this is a schema reference
+        if (name === 'schema') {
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression: 'schema',
+                _type: undefined
+            };
+        }
+        // For other identifiers, return as-is (might be local variables in complex expressions)
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression: name,
+            _type: undefined
+        };
+    }
+    /**
+     * Map JavaScript operators to CEL operators
+     */
+    mapOperatorToCel(operator) {
+        const mapping = {
+            '===': '==',
+            '!==': '!=',
+            '&&': '&&',
+            '||': '||',
+            '>': '>',
+            '<': '<',
+            '>=': '>=',
+            '<=': '<=',
+            '==': '==',
+            '!=': '!='
+        };
+        return mapping[operator] || operator;
+    }
+    /**
+     * Extract member path from AST node
+     */
+    extractMemberPath(node) {
+        if (node.type === 'Identifier') {
+            return node.name;
+        }
+        if (node.type === 'MemberExpression') {
+            const object = this.extractMemberPath(node.object);
+            if (node.computed) {
+                // For computed access like array[0] or object['key'], we need special handling
+                // This is used for path extraction, so we'll represent it differently
+                const property = this.getSourceText(node.property);
+                const optionalMarker = node.optional ? '?.' : '';
+                return `${object}${optionalMarker}[${property}]`;
+            }
+            else {
+                // For regular property access like object.property or object?.property
+                const property = node.property.name;
+                const optionalMarker = node.optional ? '?.' : '.';
+                return `${object}${optionalMarker}${property}`;
+            }
+        }
+        if (node.type === 'ChainExpression') {
+            // Handle ChainExpression wrapper for optional chaining
+            return this.extractMemberPath(node.expression);
+        }
+        throw new Error(`Cannot extract path from node type: ${node.type}`);
+    }
+    /**
+     * Check if a node represents a complex expression that can't be handled as a simple path
+     */
+    isComplexExpression(node) {
+        if (node.type === 'CallExpression') {
+            return true;
+        }
+        if (node.type === 'MemberExpression') {
+            // Recursively check if the object is complex
+            return this.isComplexExpression(node.object);
+        }
+        return false;
+    }
+    /**
+     * Get source text from AST node (placeholder implementation)
+     */
+    getSourceText(node) {
+        // For now, return a placeholder - this would need access to original source
+        if (node.type === 'Literal') {
+            return String(node.value);
+        }
+        return '<expression>';
+    }
+    /**
+     * Generate CEL expression for resource field reference
+     */
+    getResourceFieldReference(_resource, resourceKey, fieldPath, context) {
+        // Generate CEL expression for resource field reference using the correct format
+        // This should match the format used by getInnerCelPath
+        const expression = `${resourceKey}.${fieldPath}`;
+        // Create a KubernetesRef object and add it to dependencies
+        const ref = {
+            [KUBERNETES_REF_BRAND]: true,
+            resourceId: resourceKey,
+            fieldPath,
+            _type: this.inferTypeFromFieldPath(fieldPath)
+        };
+        if (!context.dependencies) {
+            context.dependencies = [];
+        }
+        context.dependencies.push(ref);
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Generate CEL expression for schema field reference
+     */
+    getSchemaFieldReference(path, context) {
+        // Create a KubernetesRef object for schema reference and add it to dependencies
+        const fieldPath = path.substring('schema.'.length);
+        const ref = {
+            [KUBERNETES_REF_BRAND]: true,
+            resourceId: '__schema__',
+            fieldPath,
+            _type: this.inferTypeFromFieldPath(fieldPath)
+        };
+        if (!context.dependencies) {
+            context.dependencies = [];
+        }
+        context.dependencies.push(ref);
+        // Generate CEL expression for schema field reference
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression: path,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.find() method calls
+     */
+    convertArrayFind(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('Array.find() requires exactly one argument');
+        }
+        // For simple property comparisons like c => c.type === "Available", we can convert to CEL
+        const arg = args[0];
+        if (arg.type === 'ArrowFunctionExpression' && arg.body.type === 'BinaryExpression') {
+            const param = arg.params[0].name;
+            const binaryExpr = arg.body;
+            // Handle the left side (should be a member expression like c.type)
+            let leftExpr;
+            if (binaryExpr.left.type === 'MemberExpression' && binaryExpr.left.object.name === param) {
+                // Simple case: c.type
+                leftExpr = `${param}.${binaryExpr.left.property.name}`;
+            }
+            else {
+                // More complex case - try to convert but replace parameter references
+                try {
+                    const leftResult = this.convertASTNode(binaryExpr.left, context);
+                    leftExpr = leftResult.expression.replace(new RegExp(`\\b${param}\\b`, 'g'), param);
+                }
+                catch {
+                    leftExpr = `${param}.property`;
+                }
+            }
+            // Handle the right side (usually a literal)
+            let rightExpr;
+            try {
+                const rightResult = this.convertASTNode(binaryExpr.right, context);
+                rightExpr = rightResult.expression;
+            }
+            catch {
+                rightExpr = 'value';
+            }
+            const operator = this.convertBinaryOperator(binaryExpr.operator);
+            const expression = `${object.expression}.filter(${param}, ${leftExpr} ${operator} ${rightExpr})[0]`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // For now, create a placeholder for complex find operations
+        const expression = `${object.expression}.filter(/* TODO: convert find predicate */)[0]`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.filter() method calls
+     */
+    convertArrayFilter(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('Array.filter() requires exactly one argument');
+        }
+        // For simple property access like i => i.ip, we can convert to CEL
+        const arg = args[0];
+        if (arg.type === 'ArrowFunctionExpression') {
+            const param = arg.params[0].name;
+            if (arg.body.type === 'MemberExpression') {
+                // Simple property access: i => i.ip
+                const property = arg.body.property.name;
+                const expression = `${object.expression}.filter(${param}, has(${param}.${property}) && ${param}.${property} != null)`;
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression,
+                    _type: undefined
+                };
+            }
+            else if (arg.body.type === 'BinaryExpression') {
+                // Binary comparison: i => i.type === "Available"
+                const left = this.convertASTNode(arg.body.left, context);
+                const operator = this.convertBinaryOperator(arg.body.operator);
+                const right = this.convertASTNode(arg.body.right, context);
+                // Replace parameter references with the iteration variable
+                const leftExpr = left.expression.replace(new RegExp(`\\b${param}\\b`, 'g'), param);
+                const rightExpr = right.expression;
+                const expression = `${object.expression}.filter(${param}, ${leftExpr} ${operator} ${rightExpr})`;
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression,
+                    _type: undefined
+                };
+            }
+        }
+        // For now, create a placeholder for complex filter operations
+        const expression = `${object.expression}.filter(/* TODO: convert filter predicate */)`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.includes() method calls
+     */
+    convertStringIncludes(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.includes() requires exactly one argument');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        const expression = `${object.expression}.contains(${searchValue.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.map() method calls
+     */
+    convertArrayMap(object, args, _context) {
+        if (args.length !== 1) {
+            throw new Error('Array.map() requires exactly one argument');
+        }
+        // For simple property access like c => c.name, we can convert to CEL
+        const arg = args[0];
+        if (arg.type === 'ArrowFunctionExpression' && arg.body.type === 'MemberExpression') {
+            const param = arg.params[0].name;
+            const property = arg.body.property.name;
+            const expression = `${object.expression}.map(${param}, ${param}.${property})`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        // For now, create a placeholder for complex map operations
+        const expression = `${object.expression}.map(/* TODO: convert map predicate */)`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.some() method calls
+     */
+    convertArraySome(object, args, _context) {
+        if (args.length !== 1) {
+            throw new Error('Array.some() requires exactly one argument');
+        }
+        // For now, create a placeholder - full implementation would need lambda support
+        const expression = `${object.expression}.exists(/* TODO: convert predicate */)`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.every() method calls
+     */
+    convertArrayEvery(object, args, _context) {
+        if (args.length !== 1) {
+            throw new Error('Array.every() requires exactly one argument');
+        }
+        // For now, create a placeholder - full implementation would need lambda support
+        const expression = `${object.expression}.all(/* TODO: convert predicate */)`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.startsWith() method calls
+     */
+    convertStringStartsWith(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.startsWith() requires exactly one argument');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        const expression = `${object.expression}.startsWith(${searchValue.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.endsWith() method calls
+     */
+    convertStringEndsWith(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.endsWith() requires exactly one argument');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        const expression = `${object.expression}.endsWith(${searchValue.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.toLowerCase() method calls
+     */
+    convertStringToLowerCase(object, args, _context) {
+        if (args.length !== 0) {
+            throw new Error('String.toLowerCase() requires no arguments');
+        }
+        const expression = `${object.expression}.lowerAscii()`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.toUpperCase() method calls
+     */
+    convertStringToUpperCase(object, args, _context) {
+        if (args.length !== 0) {
+            throw new Error('String.toUpperCase() requires no arguments');
+        }
+        const expression = `${object.expression}.upperAscii()`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.trim() method calls
+     */
+    convertStringTrim(object, args, _context) {
+        if (args.length !== 0) {
+            throw new Error('String.trim() requires no arguments');
+        }
+        // CEL doesn't have a direct trim function, so we'll use a placeholder
+        const expression = `${object.expression}.trim()`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.substring() method calls
+     */
+    convertStringSubstring(object, args, context) {
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('String.substring() requires 1 or 2 arguments');
+        }
+        const startIndex = this.convertASTNode(args[0], context);
+        if (args.length === 1) {
+            const expression = `${object.expression}.substring(${startIndex.expression})`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        else {
+            const endIndex = this.convertASTNode(args[1], context);
+            const expression = `${object.expression}.substring(${startIndex.expression}, ${endIndex.expression})`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+    }
+    /**
+     * Convert string.slice() method calls
+     */
+    convertStringSlice(object, args, context) {
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('String.slice() requires 1 or 2 arguments');
+        }
+        const startIndex = this.convertASTNode(args[0], context);
+        if (args.length === 1) {
+            const expression = `${object.expression}.substring(${startIndex.expression})`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+        else {
+            const endIndex = this.convertASTNode(args[1], context);
+            const expression = `${object.expression}.substring(${startIndex.expression}, ${endIndex.expression})`;
+            return {
+                [CEL_EXPRESSION_BRAND]: true,
+                expression,
+                _type: undefined
+            };
+        }
+    }
+    /**
+     * Convert string.split() method calls
+     */
+    convertStringSplit(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.split() requires exactly one argument');
+        }
+        const separator = this.convertASTNode(args[0], context);
+        const expression = `${object.expression}.split(${separator.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.join() method calls
+     */
+    convertArrayJoin(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('Array.join() requires exactly one argument');
+        }
+        const separator = this.convertASTNode(args[0], context);
+        const expression = `${object.expression}.join(${separator.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert array.flatMap() method calls
+     */
+    convertArrayFlatMap(object, args, _context) {
+        if (args.length !== 1) {
+            throw new Error('Array.flatMap() requires exactly one argument');
+        }
+        const arg = args[0];
+        // Handle arrow function: arr.flatMap(x => x.items)
+        if (arg.type === 'ArrowFunctionExpression') {
+            const param = arg.params[0].name;
+            if (arg.body.type === 'MemberExpression') {
+                // Simple property access: x => x.items
+                const property = arg.body.property.name;
+                const expression = `${object.expression}.map(${param}, ${param}.${property}).flatten()`;
+                return {
+                    [CEL_EXPRESSION_BRAND]: true,
+                    expression,
+                    _type: undefined
+                };
+            }
+        }
+        throw new Error('Unsupported flatMap expression');
+    }
+    /**
+     * Convert .length property access
+     */
+    convertLengthProperty(object, _context) {
+        const expression = `size(${object.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Convert string.padStart() method calls
+     */
+    convertStringPadStart(object, args, context) {
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('String.padStart() requires 1 or 2 arguments');
+        }
+        const targetLength = this.convertASTNode(args[0], context);
+        const padString = args.length > 1 ? this.convertASTNode(args[1], context) : { expression: '" "' };
+        // CEL doesn't have padStart, so we'll simulate it
+        const expression = `size(${object.expression}) >= ${targetLength.expression} ? ${object.expression} : (${padString.expression}.repeat(${targetLength.expression} - size(${object.expression})) + ${object.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'string'
+        };
+    }
+    /**
+     * Convert string.padEnd() method calls
+     */
+    convertStringPadEnd(object, args, context) {
+        if (args.length < 1 || args.length > 2) {
+            throw new Error('String.padEnd() requires 1 or 2 arguments');
+        }
+        const targetLength = this.convertASTNode(args[0], context);
+        const padString = args.length > 1 ? this.convertASTNode(args[1], context) : { expression: '" "' };
+        // CEL doesn't have padEnd, so we'll simulate it
+        const expression = `size(${object.expression}) >= ${targetLength.expression} ? ${object.expression} : (${object.expression} + ${padString.expression}.repeat(${targetLength.expression} - size(${object.expression})))`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'string'
+        };
+    }
+    /**
+     * Convert string.repeat() method calls
+     */
+    convertStringRepeat(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.repeat() requires exactly one argument');
+        }
+        const count = this.convertASTNode(args[0], context);
+        // CEL doesn't have repeat, so we'll use a simple approach for small counts
+        const expression = `${object.expression}.repeat(${count.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'string'
+        };
+    }
+    /**
+     * Convert string.replace() method calls
+     */
+    convertStringReplace(object, args, context) {
+        if (args.length !== 2) {
+            throw new Error('String.replace() requires exactly two arguments');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        const replaceValue = this.convertASTNode(args[1], context);
+        // CEL doesn't have replace, so we'll use a simple substitution
+        const expression = `${object.expression}.replace(${searchValue.expression}, ${replaceValue.expression})`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'string'
+        };
+    }
+    /**
+     * Convert string.indexOf() method calls
+     */
+    convertStringIndexOf(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.indexOf() requires exactly one argument');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        // CEL doesn't have indexOf, so we'll use a conditional approach
+        const expression = `${object.expression}.contains(${searchValue.expression}) ? 0 : -1`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'number'
+        };
+    }
+    /**
+     * Convert string.lastIndexOf() method calls
+     */
+    convertStringLastIndexOf(object, args, context) {
+        if (args.length !== 1) {
+            throw new Error('String.lastIndexOf() requires exactly one argument');
+        }
+        const searchValue = this.convertASTNode(args[0], context);
+        // CEL doesn't have lastIndexOf, so we'll use a conditional approach
+        const expression = `${object.expression}.contains(${searchValue.expression}) ? size(${object.expression}) - size(${searchValue.expression}) : -1`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: 'number'
+        };
+    }
+    /**
+     * Infer type from field path based on common Kubernetes patterns
+     */
+    inferTypeFromFieldPath(fieldPath) {
+        // Common patterns for type inference
+        if (fieldPath.includes('replicas') || fieldPath.includes('count') || fieldPath.includes('port')) {
+            return 0; // number
+        }
+        if (fieldPath.includes('ready') || fieldPath.includes('available') || fieldPath.includes('enabled')) {
+            return false; // boolean
+        }
+        if (fieldPath.includes('name') || fieldPath.includes('image') || fieldPath.includes('namespace')) {
+            return ''; // string
+        }
+        if (fieldPath.includes('labels') || fieldPath.includes('annotations')) {
+            return {}; // object
+        }
+        if (fieldPath.includes('conditions') || fieldPath.includes('ingress') || fieldPath.includes('containers')) {
+            return []; // array
+        }
+        // Default to string for unknown fields
+        return '';
+    }
+    /**
+     * Convert binary operators to CEL equivalents
+     */
+    convertBinaryOperator(operator) {
+        const operatorMap = {
+            '===': '==',
+            '!==': '!=',
+            '==': '==',
+            '!=': '!=',
+            '<': '<',
+            '<=': '<=',
+            '>': '>',
+            '>=': '>=',
+            '+': '+',
+            '-': '-',
+            '*': '*',
+            '/': '/',
+            '%': '%'
+        };
+        const celOperator = operatorMap[operator];
+        if (!celOperator) {
+            throw new Error(`Unsupported binary operator: ${operator}`);
+        }
+        return celOperator;
+    }
+    /**
+     * Convert array access expressions with KubernetesRef support (array[0], array[index])
+     */
+    convertArrayAccess(node, context) {
+        // Convert the object being accessed (could be a KubernetesRef)
+        const object = this.convertASTNode(node.object, context);
+        // Convert the index/key expression
+        const property = this.convertASTNode(node.property, context);
+        // Generate CEL array access expression
+        const expression = `${object.expression}[${property.expression}]`;
+        return {
+            [CEL_EXPRESSION_BRAND]: true,
+            expression,
+            _type: undefined
+        };
+    }
+    /**
+     * Check if a value is a static literal that doesn't need conversion
+     * Static values (no KubernetesRef objects) should be preserved as-is for performance
+     */
+    isStaticValue(value) {
+        // Primitive values are always static
+        if (value === null || value === undefined)
+            return true;
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+            return true;
+        }
+        // Check if it's a KubernetesRef (not static)
+        if (isKubernetesRef(value))
+            return false;
+        // Check if it contains KubernetesRef objects (not static)
+        if (containsKubernetesRefs(value))
+            return false;
+        // Arrays and objects need recursive checking
+        if (Array.isArray(value)) {
+            return value.every(item => this.isStaticValue(item));
+        }
+        if (value && typeof value === 'object') {
+            return Object.values(value).every(val => this.isStaticValue(val));
+        }
+        // Default to static for other types
+        return true;
+    }
+    /**
+     * Create a result for static values that don't require conversion
+     */
+    createStaticValueResult(_value) {
+        return {
+            valid: true,
+            celExpression: null, // No CEL expression needed for static values
+            dependencies: [],
+            sourceMap: [],
+            errors: [],
+            warnings: [],
+            requiresConversion: false // Key: static values don't need conversion
+        };
+    }
+    /**
+     * Analyze expression using factory pattern aware handling
+     *
+     * This method integrates with the factory pattern handler to provide
+     * appropriate expression processing based on the deployment strategy.
+     */
+    analyzeExpressionWithFactoryPattern(expression, context) {
+        try {
+            // Use the factory pattern handler for initial processing
+            const factoryResult = handleExpressionWithFactoryPattern(expression, context);
+            // If the factory handler processed it successfully, return the result
+            if (factoryResult.valid && factoryResult.celExpression) {
+                return factoryResult;
+            }
+            // If the factory handler determined no conversion is needed, return as-is
+            if (!factoryResult.requiresConversion) {
+                return factoryResult;
+            }
+            // If the factory handler couldn't process it, fall back to the main analyzer
+            if (typeof expression === 'string') {
+                return this.analyzeExpression(expression, context);
+            }
+            // For non-string expressions that need conversion, return the factory result
+            return factoryResult;
+        }
+        catch (error) {
+            return {
+                valid: false,
+                celExpression: null,
+                dependencies: [],
+                sourceMap: [],
+                errors: [new ConversionError(`Factory pattern expression analysis failed: ${error instanceof Error ? error.message : String(error)}`, String(expression), 'javascript')],
+                warnings: [],
+                requiresConversion: true
+            };
+        }
+    }
+    /**
+     * Get cache statistics for performance monitoring
+     */
+    getCacheStats() {
+        return this.cache.getStats();
+    }
+    /**
+     * Clear all caches
+     */
+    clearCache() {
+        this.cache.clear();
+    }
+    /**
+     * Force cleanup of expired cache entries
+     */
+    cleanupCache() {
+        return this.cache.cleanup();
+    }
+    /**
+     * Destroy analyzer and cleanup resources
+     */
+    destroy() {
+        this.cache.destroy();
+    }
+}
+//# sourceMappingURL=analyzer.js.map