typekro 0.4.0 → 0.7.0

package/dist/core/expressions/analyzer.js

@@ -1,2921 +0,0 @@
-/**
- * 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 estraverse from 'estraverse';
-import { parseExpression, parseScript, ParserError } from './parser.js';
-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 {
-            // Parse JavaScript expression to AST with location tracking
-            // Using unified acorn parser with native ES2022 support (optional chaining, nullish coalescing)
-            const exprNode = parseExpression(expression);
-            // Create source location from AST (handle case where loc might be undefined)
-            const astLoc = exprNode.loc;
-            const sourceLocation = astLoc
-                ? SourceMapUtils.createSourceLocation(astLoc, expression)
-                : { line: 1, column: 1, length: expression.length };
-            // 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 from ParserError if available
-            let sourceLocation = { line: 1, column: 1, length: expression.length };
-            let errorMessage = error instanceof Error ? error.message : String(error);
-            // Extract enhanced error information from ParserError
-            if (error instanceof ParserError) {
-                sourceLocation = {
-                    line: error.line,
-                    column: error.column,
-                    length: expression.length
-                };
-                errorMessage = error.message;
-            }
-            const conversionError = ConversionError.forParsingFailure(expression, errorMessage, 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 using unified acorn parser
-            const ast = 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) {
-            const errorMessage = error instanceof ParserError
-                ? error.message
-                : (error instanceof Error ? error.message : String(error));
-            return {
-                valid: false,
-                celExpression: null,
-                dependencies: [],
-                sourceMap: [],
-                errors: [new ConversionError(errorMessage, 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
-     * Note: With acorn's native ES2022 support, optional chaining is parsed directly.
-     * This method is kept for backward compatibility and special case handling.
-     */
-    handleOptionalChainingExpression(expression, context) {
-        try {
-            // Validate that the expression is syntactically valid JavaScript
-            // Acorn natively supports optional chaining (ES2020+)
-            try {
-                parseExpression(expression);
-            }
-            catch (syntaxError) {
-                const errorMessage = syntaxError instanceof ParserError
-                    ? syntaxError.message
-                    : (syntaxError instanceof Error ? syntaxError.message : String(syntaxError));
-                throw new ConversionError(`Invalid JavaScript syntax in optional chaining expression: ${errorMessage}`, 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
-     * Note: With acorn's native ES2022 support, nullish coalescing is parsed directly.
-     * This method converts ?? to CEL-compatible conditional syntax.
-     */
-    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
-        };
-    }
-    /**
-     * 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