timonel 2.8.1 → 2.9.0

package/dist/lib/rutter.js

@@ -1,304 +1,59 @@
 import { ApiObject, App, Chart, Testing } from 'cdk8s';
+import Handlebars from 'handlebars';
 import YAML from 'yaml';
 import { helm, include } from './helm.js';
 import { HelmChartWriter } from './helmChartWriter.js';
 import { AWSResources } from './resources/cloud/aws/awsResources.js';
 import { KarpenterResources } from './resources/cloud/aws/karpenterResources.js';
 import { generateHelpersTemplate } from './utils/helmHelpers.js';
-/**
- * Rutter class with modular architecture
- * Provides a clean API while delegating to specialized resource providers
- * Maintains full backward compatibility with the original Rutter class
- *
- * @since 2.4.0
- */
 export class Rutter {
     constructor(props) {
         this.assets = [];
-        this.props = props;
-        this.meta = props.meta;
         this.defaultValues = props.defaultValues ?? {};
         this.envValues = props.envValues ?? {};
-        // Create CDK8s infrastructure
+        this.meta = props.meta;
+        this.props = props;
         this.app = new App();
         this.chart = new Chart(this.app, props.meta.name, {
             ...props.chartProps,
             ...(props.namespace ? { namespace: props.namespace } : {}),
         });
-        // Initialize resource providers
         this.awsResources = new AWSResources(this.chart);
         this.karpenterResources = new KarpenterResources(this.chart);
     }
-    // AWS Resources
-    /**
-     * Creates an AWS EBS StorageClass
-     * @param spec - EBS StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAWSEBSStorageClass({
-     *   name: 'fast-ebs',
-     *   volumeType: 'gp3',
-     *   encrypted: true,
-     *   allowVolumeExpansion: true
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
     addAWSEBSStorageClass(spec) {
         return this.awsResources.addEBSStorageClass(spec);
     }
-    /**
-     * Creates an AWS EFS StorageClass
-     * @param spec - EFS StorageClass specification
-     * @returns Created StorageClass ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAWSEFSStorageClass({
-     *   name: 'efs-storage',
-     *   fileSystemId: 'fs-12345678',
-     *   directoryPerms: '0755'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
     addAWSEFSStorageClass(spec) {
         return this.awsResources.addEFSStorageClass(spec);
     }
-    /**
-     * Creates an AWS IRSA ServiceAccount
-     * @param spec - IRSA ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAWSIRSAServiceAccount({
-     *   name: 'my-service-account',
-     *   roleArn: 'arn:aws:iam::ACCOUNT_ID:role/MyRole'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
     addAWSIRSAServiceAccount(spec) {
         return this.awsResources.addIRSAServiceAccount(spec);
     }
-    /**
-     * Creates an AWS ALB Ingress
-     * @param spec - ALB Ingress specification
-     * @returns Created Ingress ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAWSALBIngress({
-     *   name: 'web-ingress',
-     *   rules: [{
-     *     paths: [{
-     *       path: '/',
-     *       pathType: 'Prefix',
-     *       backend: { service: { name: 'web-service', port: { number: 80 } } }
-     *     }]
-     *   }],
-     *   scheme: 'internet-facing'
-     * });
-     * ```
-     *
-     * @since 1.0.0
-     */
     addAWSALBIngress(spec) {
         return this.awsResources.addALBIngress(spec);
     }
-    // AWS Karpenter Resources
-    /**
-     * Creates a Karpenter NodePool resource
-     * @param spec - NodePool specification
-     * @returns Created NodePool ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addKarpenterNodePool({
-     *   name: 'default-nodepool',
-     *   template: {
-     *     spec: {
-     *       nodeClassRef: {
-     *         apiVersion: 'karpenter.k8s.aws/v1beta1',
-     *         kind: 'EC2NodeClass',
-     *         name: 'default'
-     *       }
-     *     }
-     *   }
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
     addKarpenterNodePool(spec) {
         return this.karpenterResources.addKarpenterNodePool(spec);
     }
-    /**
-     * Creates a Karpenter NodeClaim resource
-     * @param spec - NodeClaim specification
-     * @returns Created NodeClaim ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addKarpenterNodeClaim({
-     *   name: 'my-node-claim',
-     *   nodeClassRef: {
-     *     apiVersion: 'karpenter.k8s.aws/v1beta1',
-     *     kind: 'EC2NodeClass',
-     *     name: 'default'
-     *   }
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
     addKarpenterNodeClaim(spec) {
         return this.karpenterResources.addKarpenterNodeClaim(spec);
     }
-    /**
-     * Creates a Karpenter EC2NodeClass resource
-     * @param spec - EC2NodeClass specification
-     * @returns Created EC2NodeClass ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addKarpenterEC2NodeClass({
-     *   name: 'default',
-     *   amiFamily: 'AL2',
-     *   subnetSelectorTerms: [{ tags: { 'karpenter.sh/discovery': 'my-cluster' } }],
-     *   securityGroupSelectorTerms: [{ tags: { 'karpenter.sh/discovery': 'my-cluster' } }]
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
     addKarpenterEC2NodeClass(spec) {
         return this.karpenterResources.addKarpenterEC2NodeClass(spec);
     }
-    /**
-     * Creates a Karpenter NodePool with optimized disruption settings for cost efficiency
-     * @param spec - NodePool specification with disruption optimization
-     * @returns Created NodePool ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addKarpenterNodePoolWithDisruption({
-     *   name: 'cost-optimized',
-     *   nodeClassRef: {
-     *     apiVersion: 'karpenter.k8s.aws/v1beta1',
-     *     kind: 'EC2NodeClass',
-     *     name: 'default'
-     *   },
-     *   consolidationPolicy: 'WhenEmptyOrUnderutilized',
-     *   consolidateAfter: '30s',
-     *   expireAfter: '24h',
-     *   disruptionBudgets: [
-     *     { nodes: '20%' },
-     *     { nodes: '0', schedule: '0 9 * * 1-5', duration: '8h' }
-     *   ]
-     * });
-     * ```
-     *
-     * @since 2.7.1
-     */
     addKarpenterNodePoolWithDisruption(spec) {
         return this.karpenterResources.addKarpenterNodePoolWithDisruption(spec);
     }
-    /**
-     * Creates a Karpenter NodePool with scheduling constraints and priorities
-     * @param spec - NodePool specification with scheduling optimization
-     * @returns Created NodePool ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addKarpenterNodePoolWithScheduling({
-     *   name: 'gpu-workloads',
-     *   nodeClassRef: {
-     *     apiVersion: 'karpenter.k8s.aws/v1beta1',
-     *     kind: 'EC2NodeClass',
-     *     name: 'gpu-nodeclass'
-     *   },
-     *   requirements: [
-     *     { key: 'node.kubernetes.io/instance-type', operator: 'In', values: ['g4dn.xlarge', 'g4dn.2xlarge'] }
-     *   ],
-     *   taints: [
-     *     { key: 'nvidia.com/gpu', effect: 'NoSchedule' }
-     *   ],
-     *   terminationGracePeriod: '60s',
-     *   weight: 100
-     * });
-     * ```
-     *
-     * @since 2.7.1
-     */
     addKarpenterNodePoolWithScheduling(spec) {
         return this.karpenterResources.addKarpenterNodePoolWithScheduling(spec);
     }
-    // AWS ECR ServiceAccount
-    /**
-     * Creates a ServiceAccount with ECR access annotations
-     * @param spec - ECR ServiceAccount specification
-     * @returns Created ServiceAccount ApiObject
-     *
-     * @example
-     * ```typescript
-     * rutter.addAWSECRServiceAccount({
-     *   name: 'ecr-service-account',
-     *   roleArn: 'arn:aws:iam::ACCOUNT_ID:role/ECRAccessRole'
-     * });
-     * ```
-     *
-     * @since 2.7.0
-     */
     addAWSECRServiceAccount(spec) {
         return this.awsResources.addECRServiceAccount(spec);
     }
-    // Utility methods
-    /**
-     * Adds a Kubernetes manifest to the chart using CDK8S
-     *
-     * This method allows you to add any Kubernetes manifest (CRDs, custom resources, etc.)
-     * either as YAML strings or as objects. The manifest will be processed using CDK8S
-     * for better type safety and validation.
-     *
-     * @param yamlOrObject - Kubernetes manifest as YAML string or object
-     * @param id - Unique identifier for the manifest (required for multiple manifests)
-     *
-     * @example
-     * ```typescript
-     * // Using YAML string for CRD
-     * rutter.addManifest(`
-     * apiVersion: apiextensions.k8s.io/v1
-     * kind: CustomResourceDefinition
-     * metadata:
-     *   name: example.com
-     * spec:
-     *   group: example.com
-     *   versions: []
-     * `, 'my-crd');
-     *
-     * // Using object for any Kubernetes resource
-     * rutter.addManifest({
-     *   apiVersion: 'v1',
-     *   kind: 'ConfigMap',
-     *   metadata: { name: 'my-config' },
-     *   data: { key: 'value' }
-     * }, 'my-configmap');
-     * ```
-     *
-     * @since 3.0.0
-     * @note Consider using cdk8s-plus constructs for better type safety when available
-     */
     addManifest(yamlOrObject, id) {
         let manifestObject;
         if (typeof yamlOrObject === 'string') {
-            // Parse YAML string to object
             try {
                 manifestObject = YAML.parse(yamlOrObject);
             }
@@ -307,15 +62,12 @@ export class Rutter {
             }
         }
         else if (typeof yamlOrObject === 'object' && yamlOrObject !== null) {
-            // Use object directly
             manifestObject = yamlOrObject;
         }
         else {
             throw new Error('addManifest() requires either a YAML string or an object');
         }
-        // Validate basic Kubernetes manifest structure
         this.validateManifestStructure(manifestObject);
-        // Create CDK8S ApiObject from the manifest
         return new ApiObject(this.chart, id, {
             apiVersion: manifestObject['apiVersion'],
             kind: manifestObject['kind'],
@@ -323,55 +75,57 @@ export class Rutter {
             spec: manifestObject['spec'],
         });
     }
-    /**
-     * Adds a Kubernetes manifest wrapped in a Helm conditional
-     *
-     * This method creates a manifest that will only be rendered if the specified
-     * condition evaluates to true. The condition is checked against .Values in Helm.
-     *
-     * @param manifestObject - JavaScript object representing the Kubernetes manifest
-     * @param condition - Path to the condition value in .Values (e.g., 'createNamespace')
-     * @param id - Unique identifier for this manifest within the chart
-     * @returns The created ApiObject instance
-     * @throws {Error} If the manifest structure is incorrect or condition path is invalid
-     *
-     * @example
-     * ```typescript
-     * // Add a namespace that's only created if .Values.createNamespace is true
-     * rutter.addConditionalManifest(
-     *   {
-     *     apiVersion: 'v1',
-     *     kind: 'Namespace',
-     *     metadata: {
-     *       name: valuesRef('namespace'),
-     *       labels: {
-     *         environment: conditionalRef('environment', 'environment')
-     *       }
-     *     }
-     *   },
-     *   'createNamespace',
-     *   'namespace'
-     * );
-     * ```
-     *
-     * @since 2.7.4
-     */
+    addTemplateManifest(yamlTemplate, id) {
+        const templateAsset = {
+            id,
+            yaml: yamlTemplate,
+            target: 'templates',
+        };
+        this.assets.push(templateAsset);
+        return new ApiObject(this.chart, id, {
+            apiVersion: 'v1',
+            kind: 'ConfigMap',
+            metadata: { name: id },
+        });
+    }
     addConditionalManifest(manifestObject, condition, id) {
-        // Validate condition path
         if (!condition || typeof condition !== 'string') {
             throw new Error('Condition must be a non-empty string');
         }
-        // Validate basic Kubernetes manifest structure
         this.validateManifestStructure(manifestObject);
-        // Store the manifest as a conditional asset that will be processed during write
-        const conditionalAsset = {
-            id,
-            yaml: `{{- if .Values.${condition} }}\n${YAML.stringify(manifestObject)}{{- end }}`,
-            target: 'templates',
-        };
-        this.assets.push(conditionalAsset);
-        // Create a placeholder CDK8S ApiObject for consistency
-        return new ApiObject(this.chart, id, {
+        let helmCondition;
+        if (condition.startsWith('{{') && condition.endsWith('}}')) {
+            helmCondition = condition.slice(2, -2).trim();
+        }
+        else {
+            helmCondition = `.Values.${condition}`;
+        }
+        try {
+            const yamlContent = YAML.stringify(manifestObject, {
+                lineWidth: 0,
+                doubleQuotedAsJSON: false,
+                simpleKeys: true,
+            });
+            const conditionalTemplate = `\\{{- if ${helmCondition} }}
+{{{manifestYaml}}}
+\\{{- end }}`;
+            const template = Handlebars.compile(conditionalTemplate, {
+                noEscape: true,
+            });
+            const conditionalYaml = template({
+                manifestYaml: yamlContent.trim(),
+            });
+            const conditionalAsset = {
+                id,
+                yaml: conditionalYaml,
+                target: 'templates',
+            };
+            this.assets.push(conditionalAsset);
+        }
+        catch (error) {
+            throw new Error(`Failed to compile Handlebars template for manifest '${id}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+        }
+        return new ApiObject(this.chart, `${id}-placeholder`, {
             apiVersion: manifestObject['apiVersion'],
             kind: manifestObject['kind'],
             metadata: {
@@ -379,17 +133,12 @@ export class Rutter {
                 annotations: {
                     ...(manifestObject['metadata']?.['annotations'] || {}),
                     'timonel.sh/conditional': condition,
+                    'timonel.sh/placeholder': 'true',
                 },
             },
             spec: manifestObject['spec'],
         });
     }
-    /**
-     * Validates the structure of a Kubernetes manifest object
-     * @param manifest - The manifest object to validate
-     * @private
-     * @since 3.0.0
-     */
     validateManifestStructure(manifest) {
         if (!manifest['apiVersion'] || typeof manifest['apiVersion'] !== 'string') {
             throw new Error('Kubernetes manifest must have a valid apiVersion');
@@ -406,7 +155,6 @@ export class Rutter {
         if (!metadata['name'] || typeof metadata['name'] !== 'string') {
             throw new Error('Kubernetes manifest metadata must have a valid name');
         }
-        // Additional validation for specific resource types
         const kind = manifest['kind'];
         if (kind === 'CustomResourceDefinition') {
             if (!manifest['spec'] || typeof manifest['spec'] !== 'object' || manifest['spec'] === null) {
@@ -421,59 +169,35 @@ export class Rutter {
             }
         }
     }
-    /**
-     * Gets chart metadata
-     * @returns Chart metadata
-     *
-     * @since 1.0.0
-     */
     getMeta() {
         return { ...this.meta };
     }
-    /**
-     * Gets default values
-     * @returns Default values object
-     *
-     * @since 1.0.0
-     */
     getDefaultValues() {
         return { ...this.defaultValues };
     }
-    /**
-     * Gets environment-specific values
-     * @returns Environment values object
-     *
-     * @since 1.0.0
-     */
     getEnvValues() {
         return { ...this.envValues };
     }
-    /**
-     * Gets all assets (CRDs, etc.)
-     * @returns Array of assets
-     *
-     * @since 1.0.0
-     */
     getAssets() {
         return [...this.assets];
     }
-    /**
-     * Converts the chart to SynthAsset array for HelmChartWriter
-     * @returns Array of synthesized assets
-     *
-     * @since 2.4.0
-     */
     toSynthArray() {
-        // Get ApiObject IDs before synthesis
+        console.log('🔍 toSynthArray called');
         const apiObjectIds = [];
         for (const child of this.chart.node.children) {
-            if (child instanceof ApiObject) {
+            if (child instanceof ApiObject && !child.node.id.endsWith('-placeholder')) {
                 apiObjectIds.push(child.node.id);
             }
         }
-        // Use cdk8s Testing.synth to obtain manifest objects
-        const manifestObjs = Testing.synth(this.chart);
-        // Enforce common labels best-practice on all rendered objects
+        const allManifestObjs = Testing.synth(this.chart);
+        const manifestObjs = allManifestObjs.filter((obj) => {
+            if (obj && typeof obj === 'object') {
+                const o = obj;
+                const annotations = o.metadata?.annotations || {};
+                return annotations['timonel.sh/placeholder'] !== 'true';
+            }
+            return true;
+        });
         const enriched = manifestObjs.map((obj) => {
             if (obj && typeof obj === 'object') {
                 const o = obj;
@@ -488,10 +212,8 @@ export class Rutter {
                     'app.kubernetes.io/managed-by': '{{ .Release.Service }}',
                     'app.kubernetes.io/part-of': helm.chartName,
                 };
-                // Apply defaults only if not already set
                 for (const [key, value] of Object.entries(defaults)) {
                     if (!(key in labels)) {
-                        // eslint-disable-next-line security/detect-object-injection -- Safe: controlled label assignment
                         labels[key] = value;
                     }
                 }
@@ -499,8 +221,8 @@ export class Rutter {
             return obj;
         });
         const synthAssets = [];
+        console.log('🔍 singleManifestFile:', this.props.singleManifestFile);
         if (this.props.singleManifestFile) {
-            // Combine all resources into single manifest
             const combinedYaml = enriched
                 .map((obj) => this.processHelmTemplates(YAML.stringify(obj).trim()))
                 .filter(Boolean)
@@ -509,47 +231,245 @@ export class Rutter {
             synthAssets.push({ id: manifestId, yaml: combinedYaml });
         }
         else {
-            // Create separate files for each resource (default behavior)
             enriched.forEach((obj, index) => {
+                const apiObjectId = apiObjectIds[index];
+                const manifestId = apiObjectId || `manifest-${index + 1}`;
+                console.log(`🔍 Processing asset ${manifestId} (index ${index})`);
                 const yaml = this.processHelmTemplates(YAML.stringify(obj).trim());
                 if (yaml) {
-                    // Use descriptive name from ApiObject ID if available, otherwise fallback to generic name
-                    // eslint-disable-next-line security/detect-object-injection
-                    const apiObjectId = apiObjectIds[index];
-                    const manifestId = apiObjectId || `manifest-${index + 1}`;
                     synthAssets.push({ id: manifestId, yaml });
                 }
             });
         }
-        // Add any additional assets (CRDs, etc.)
         this.assets.forEach((asset) => {
             synthAssets.push({ id: asset.id, yaml: asset.yaml });
         });
         return synthAssets;
     }
-    /**
-     * Process YAML content to remove quotes from Helm templates
-     * This fixes the issue where YAML.stringify adds quotes around Helm template expressions
-     * Removes quotes from all Helm template expressions
-     */
     processHelmTemplates(yaml) {
-        // Remove quotes from Helm template expressions
-        // Match patterns like "{{ .Values.replicas | int }}", "{{ .Release.Name }}", etc.
-        // Handle both key-value pairs and standalone values
-        return yaml
-            .replace(/": "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/: "\{\{([^}]+)\}\}"/g, ': {{ $1 }}')
-            .replace(/"\{\{([^}]+)\}\}"/g, '{{ $1 }}')
-            .replace(/": "\.nan"/g, ': .nan');
-    }
-    /**
-     * Writes the Helm chart to the specified output directory
-     * @param outDir - Output directory path
-     *
-     * @since 1.0.0
-     */
+        console.log('🔍 processHelmTemplates called with YAML length:', yaml.length);
+        if (yaml.includes('{{ .Values.port }}')) {
+            console.log('🎯 Found YAML with port template:');
+            const portIndex = yaml.indexOf('{{ .Values.port }}');
+            console.log(yaml.substring(Math.max(0, portIndex - 50), portIndex + 100));
+        }
+        let processed = this.fixCharacterMappingIssues(yaml);
+        processed = this.applyHelmTemplateReplacements(processed);
+        console.log('✅ processHelmTemplates completed');
+        return processed;
+    }
+    fixCharacterMappingIssues(yaml) {
+        const lines = yaml.split('\n');
+        const fixedLines = [];
+        let i = 0;
+        while (i < lines.length) {
+            const line = lines[i];
+            if (!line) {
+                i++;
+                continue;
+            }
+            const charKeyMatch = line.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (charKeyMatch && charKeyMatch[2] && parseInt(charKeyMatch[2]) === 0) {
+                const indent = charKeyMatch[1] || '';
+                const result = this.processCharacterMapping(lines, i, indent);
+                if (result.reconstructed) {
+                    fixedLines.push(result.reconstructed);
+                    i = result.nextIndex;
+                    continue;
+                }
+            }
+            if (line) {
+                fixedLines.push(line);
+            }
+            i++;
+        }
+        return fixedLines.join('\n');
+    }
+    processCharacterMapping(lines, startIndex, indent) {
+        const charMappings = [];
+        let j = startIndex;
+        while (j < lines.length) {
+            const currentLine = lines[j];
+            if (!currentLine) {
+                break;
+            }
+            const currentMatch = currentLine.match(/^(\s*)"(\d+)":\s*(.+)$/);
+            if (currentMatch && currentMatch[1] === indent && currentMatch[2] && currentMatch[3]) {
+                const index = parseInt(currentMatch[2]);
+                let char = currentMatch[3];
+                if (char && char.startsWith('"') && char.endsWith('"')) {
+                    char = char.slice(1, -1);
+                }
+                charMappings.push({ index, char });
+                j++;
+            }
+            else {
+                break;
+            }
+        }
+        if (charMappings.length > 3) {
+            charMappings.sort((a, b) => a.index - b.index);
+            const reconstructed = charMappings.map((m) => m.char).join('');
+            if (reconstructed.includes('{{') && reconstructed.includes('}}')) {
+                return { reconstructed: `${indent}${reconstructed}`, nextIndex: j };
+            }
+        }
+        return { nextIndex: j };
+    }
+    applyHelmTemplateReplacements(processed) {
+        processed = this.fixIncludeStatements(processed);
+        processed = this.fixFunctionCalls(processed);
+        processed = this.fixChartReferences(processed);
+        processed = this.removeHelmExpressionQuotes(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixConditionalBlocks:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixConditionalBlocks(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixConditionalBlocks:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixPipeExpressions:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixPipeExpressions(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixPipeExpressions:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before fixNestedQuotes:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.fixNestedQuotes(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After fixNestedQuotes:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        if (processed.includes('number:')) {
+            console.log('DEBUG: Before cleanupArtifacts:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = this.cleanupArtifacts(processed);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: After cleanupArtifacts:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        return processed;
+    }
+    fixIncludeStatements(processed) {
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \| nindent (\d+) \}\}/g, '{{ include "$1" . | nindent $2 }}');
+        processed = processed.replace(/\{\{ include \\"([^"]+)\\" \. \}\}/g, '{{ include "$1" . }}');
+        return processed;
+    }
+    fixFunctionCalls(processed) {
+        return processed.replace(/\{\{ (\w+) \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ $1 "$2" $3 }}');
+    }
+    fixChartReferences(processed) {
+        return processed.replace(/\{\{ \.Chart\.(\w+) \| replace \\"([^"]*)\\" \\"([^"]*)\\" ([^}]*) \}\}/g, '{{ .Chart.$1 | replace "$2" "$3" $4 }}');
+    }
+    removeHelmExpressionQuotes(processed) {
+        const HELM_EXPRESSION_REPLACEMENT = '$1$2: {{$3}}';
+        console.log('🔧 removeHelmExpressionQuotes called');
+        if (processed.includes('number:')) {
+            console.log('DEBUG: removeHelmExpressionQuotes input contains number:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\|\s*(?:int|float|bool|number)[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(service\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backend\.service\.port\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(spec\.port):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]*\.number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        const numberMatches = processed.match(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm);
+        if (numberMatches) {
+            console.log('DEBUG: Found number pattern matches:', numberMatches);
+        }
+        else {
+            const anyNumberFields = processed.match(/number:\s*"[^"]*"/gm);
+            if (anyNumberFields) {
+                console.log('DEBUG: Found number fields but regex did not match:', anyNumberFields);
+                const lines = processed.split('\n');
+                const numberLines = lines.filter((line) => line.includes('number:'));
+                console.log('DEBUG: Number field lines:', numberLines);
+            }
+        }
+        processed = processed.replace(/^(\s*)(number):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        if (processed.includes('number:')) {
+            console.log('DEBUG: removeHelmExpressionQuotes after number replacement:', processed.split('\n').filter((line) => line.includes('number:')));
+        }
+        processed = processed.replace(/^(\s*)(replicas):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(targetPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(nodePort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(containerPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(hostPort):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(weight):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(priority):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(timeoutSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(periodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(successThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(failureThreshold):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(initialDelaySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(terminationGracePeriodSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(activeDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(backoffLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(parallelism):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(completions):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(revisionHistoryLimit):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(progressDeadlineSeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(minReadySeconds):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxUnavailable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(maxSurge):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(cpu):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(memory):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(enabled):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(create):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allow):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(disable):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(force):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(required):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(optional):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnly):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(runAsNonRoot):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(privileged):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(allowPrivilegeEscalation):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)(readOnlyRootFilesystem):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*true[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*false[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\d+[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\beq\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bne\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\blt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\ble\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bgt\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bge\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\band\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bor\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*\bnot\b[^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[+][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[-][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*[*][^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/:\s*"([^"]*\{\{[^}]+\}\}[^"]*)"/g, ': $1');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(true|false)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"(-?\d+\.?\d*[eE][+-]?\d+)"$/gm, '$1$2: $3');
+        processed = processed.replace(/^(\s*)([^:\s]+):\s*"\{\{([^}]*)\}\}"/gm, HELM_EXPRESSION_REPLACEMENT);
+        processed = processed.replace(/"\{\{([^}]*)\}\}"/g, '{{$1}}');
+        processed = processed.replace(/^(\s*)-\s*"\{\{([^}]*)\}\}"/gm, '$1- {{$2}}');
+        return processed;
+    }
+    fixConditionalBlocks(processed) {
+        return processed.replace(/"\{\{-\s*(if|with|range)([^}]*)\}\}([^"]*)\{\{-\s*end\s*\}\}"/g, '{{- $1$2}}$3{{- end }}');
+    }
+    fixPipeExpressions(processed) {
+        return processed.replace(/"\{\{([^}]*\|[^}]*)\}\}"/g, '{{$1}}');
+    }
+    fixNestedQuotes(processed) {
+        return processed.replace(/\{\{([^}]*)\\"([^"]*)\\"([^}]*)\}\}/g, '{{$1"$2"$3}}');
+    }
+    cleanupArtifacts(processed) {
+        processed = processed.replace(/": "\.nan"/g, ': .nan');
+        processed = processed.replace(/: \{\{([^}]+)\}\}$/gm, ': {{$1}}');
+        return processed;
+    }
     write(outDir) {
-        // Generate helpers template
+        console.log('🚀 Rutter.write called with outDir:', outDir);
+        console.log('📊 Assets count:', this.assets.length);
         let helpersContent;
         if (this.props.helpersTpl) {
             if (typeof this.props.helpersTpl === 'string') {
@@ -567,19 +487,19 @@ ${helper.template}
             }
         }
         else {
-            // Auto-generate standard helpers
             helpersContent = generateHelpersTemplate(this.props.cloudProvider);
         }
+        const synthAssets = this.toSynthArray();
+        console.log('📦 Generated synth assets:', synthAssets.length);
         HelmChartWriter.write({
             outDir,
             meta: this.meta,
             defaultValues: this.defaultValues,
             envValues: this.envValues,
-            assets: this.toSynthArray(),
+            assets: synthAssets,
             helpersTpl: helpersContent,
         });
+        console.log('✅ Rutter.write completed');
     }
 }
-// Constants for labels
 Rutter.HELPER_NAME = 'chart.name';
-//# sourceMappingURL=rutter.js.map