timonel 3.0.0 → 3.1.0

package/dist/lib/policy/validationCache.js

@@ -0,0 +1,289 @@
+import { createLogger } from '../utils/logger.js';
+const DEFAULT_CACHE_OPTIONS = {
+    maxEntries: 1000,
+    maxAge: 30 * 60 * 1000,
+    enableCompression: false,
+    evictionStrategy: 'lru',
+    cacheFailures: true,
+    minExecutionTimeToCache: 10,
+};
+export class ValidationCache {
+    constructor(options = {}) {
+        this.cache = new Map();
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            entries: 0,
+            memoryUsage: 0,
+            hitRatio: 0,
+            averageAccessCount: 0,
+        };
+        this.options = { ...DEFAULT_CACHE_OPTIONS, ...options };
+        this.logger = createLogger('validation-cache');
+        this.logger.debug('ValidationCache initialized', {
+            options: this.options,
+            operation: 'cache_init',
+        });
+        this.startPeriodicCleanup();
+    }
+    get(manifestHash, pluginHash) {
+        const cacheKey = this.generateCacheKey(manifestHash, pluginHash);
+        const entry = this.cache.get(cacheKey);
+        if (!entry) {
+            this.stats.misses++;
+            this.updateStats();
+            this.logger.debug('Cache miss', {
+                manifestHash: manifestHash.substring(0, 8),
+                pluginHash: pluginHash.substring(0, 8),
+                operation: 'cache_miss',
+            });
+            return undefined;
+        }
+        if (this.isExpired(entry)) {
+            this.cache.delete(cacheKey);
+            this.stats.misses++;
+            this.updateStats();
+            this.logger.debug('Cache entry expired', {
+                manifestHash: manifestHash.substring(0, 8),
+                pluginHash: pluginHash.substring(0, 8),
+                age: Date.now() - entry.timestamp,
+                operation: 'cache_expired',
+            });
+            return undefined;
+        }
+        entry.accessCount++;
+        entry.lastAccessed = Date.now();
+        this.stats.hits++;
+        this.updateStats();
+        this.logger.debug('Cache hit', {
+            manifestHash: manifestHash.substring(0, 8),
+            pluginHash: pluginHash.substring(0, 8),
+            accessCount: entry.accessCount,
+            age: Date.now() - entry.timestamp,
+            operation: 'cache_hit',
+        });
+        return entry.result;
+    }
+    set(manifestHash, pluginHash, result) {
+        if (!this.shouldCache(result)) {
+            this.logger.debug('Skipping cache storage', {
+                manifestHash: manifestHash.substring(0, 8),
+                pluginHash: pluginHash.substring(0, 8),
+                executionTime: result.metadata.executionTime,
+                hasViolations: result.violations.length > 0,
+                operation: 'cache_skip',
+            });
+            return;
+        }
+        const cacheKey = this.generateCacheKey(manifestHash, pluginHash);
+        if (this.cache.size >= this.options.maxEntries) {
+            this.evictEntries();
+        }
+        const entry = {
+            result,
+            timestamp: Date.now(),
+            manifestHash,
+            pluginHash,
+            accessCount: 0,
+            lastAccessed: Date.now(),
+        };
+        this.cache.set(cacheKey, entry);
+        this.updateStats();
+        this.logger.debug('Cache entry stored', {
+            manifestHash: manifestHash.substring(0, 8),
+            pluginHash: pluginHash.substring(0, 8),
+            executionTime: result.metadata.executionTime,
+            violationCount: result.violations.length,
+            warningCount: result.warnings.length,
+            operation: 'cache_store',
+        });
+    }
+    invalidate(criteria) {
+        if (criteria.all) {
+            return this.invalidateAll();
+        }
+        return this.invalidateSelective(criteria);
+    }
+    invalidateAll() {
+        const invalidatedCount = this.cache.size;
+        this.cache.clear();
+        this.logger.info('Cache cleared completely', {
+            invalidatedCount,
+            operation: 'cache_clear_all',
+        });
+        this.updateStats();
+        return invalidatedCount;
+    }
+    invalidateSelective(criteria) {
+        const keysToDelete = [];
+        for (const [key, entry] of this.cache.entries()) {
+            if (this.shouldInvalidateEntry(entry, criteria)) {
+                keysToDelete.push(key);
+            }
+        }
+        for (const key of keysToDelete) {
+            this.cache.delete(key);
+        }
+        this.logger.debug('Cache entries invalidated', {
+            invalidatedCount: keysToDelete.length,
+            criteria,
+            operation: 'cache_invalidate',
+        });
+        this.updateStats();
+        return keysToDelete.length;
+    }
+    shouldInvalidateEntry(entry, criteria) {
+        if (criteria.manifestHash && entry.manifestHash === criteria.manifestHash) {
+            return true;
+        }
+        if (criteria.pluginHash && entry.pluginHash === criteria.pluginHash) {
+            return true;
+        }
+        if (criteria.olderThan && entry.timestamp < criteria.olderThan) {
+            return true;
+        }
+        return false;
+    }
+    getStats() {
+        return { ...this.stats };
+    }
+    clearStats() {
+        this.stats = {
+            hits: 0,
+            misses: 0,
+            entries: this.cache.size,
+            memoryUsage: this.estimateMemoryUsage(),
+            hitRatio: 0,
+            averageAccessCount: 0,
+        };
+        this.logger.debug('Cache statistics cleared', {
+            operation: 'cache_stats_clear',
+        });
+    }
+    generateCacheKey(manifestHash, pluginHash) {
+        return `${manifestHash}:${pluginHash}`;
+    }
+    isExpired(entry) {
+        return Date.now() - entry.timestamp > this.options.maxAge;
+    }
+    shouldCache(result) {
+        if (result.metadata.executionTime < this.options.minExecutionTimeToCache) {
+            return false;
+        }
+        if (!this.options.cacheFailures && !result.valid) {
+            return false;
+        }
+        return true;
+    }
+    evictEntries() {
+        const entriesToEvict = Math.max(1, Math.floor(this.options.maxEntries * 0.1));
+        switch (this.options.evictionStrategy) {
+            case 'lru':
+                this.evictLRU(entriesToEvict);
+                break;
+            case 'lfu':
+                this.evictLFU(entriesToEvict);
+                break;
+            case 'ttl':
+                this.evictTTL(entriesToEvict);
+                break;
+        }
+        this.logger.debug('Cache entries evicted', {
+            strategy: this.options.evictionStrategy,
+            evictedCount: entriesToEvict,
+            remainingEntries: this.cache.size,
+            operation: 'cache_evict',
+        });
+    }
+    evictLRU(count) {
+        const entries = Array.from(this.cache.entries())
+            .sort(([, a], [, b]) => a.lastAccessed - b.lastAccessed)
+            .slice(0, count);
+        for (const [key] of entries) {
+            this.cache.delete(key);
+        }
+    }
+    evictLFU(count) {
+        const entries = Array.from(this.cache.entries())
+            .sort(([, a], [, b]) => a.accessCount - b.accessCount)
+            .slice(0, count);
+        for (const [key] of entries) {
+            this.cache.delete(key);
+        }
+    }
+    evictTTL(count) {
+        const entries = Array.from(this.cache.entries())
+            .sort(([, a], [, b]) => a.timestamp - b.timestamp)
+            .slice(0, count);
+        for (const [key] of entries) {
+            this.cache.delete(key);
+        }
+    }
+    updateStats() {
+        const totalRequests = this.stats.hits + this.stats.misses;
+        this.stats.entries = this.cache.size;
+        this.stats.memoryUsage = this.estimateMemoryUsage();
+        this.stats.hitRatio = totalRequests > 0 ? this.stats.hits / totalRequests : 0;
+        if (this.cache.size > 0) {
+            const totalAccessCount = Array.from(this.cache.values()).reduce((sum, entry) => sum + entry.accessCount, 0);
+            this.stats.averageAccessCount = totalAccessCount / this.cache.size;
+        }
+        else {
+            this.stats.averageAccessCount = 0;
+        }
+    }
+    estimateMemoryUsage() {
+        let totalSize = 0;
+        for (const entry of this.cache.values()) {
+            totalSize += JSON.stringify(entry.result).length * 2;
+            totalSize += entry.manifestHash.length * 2;
+            totalSize += entry.pluginHash.length * 2;
+            totalSize += 64;
+        }
+        return totalSize;
+    }
+    startPeriodicCleanup() {
+        const cleanupInterval = Math.min(this.options.maxAge / 4, 5 * 60 * 1000);
+        globalThis.setInterval(() => {
+            this.cleanupExpiredEntries();
+        }, cleanupInterval);
+    }
+    cleanupExpiredEntries() {
+        const keysToDelete = [];
+        const now = Date.now();
+        for (const [key, entry] of this.cache.entries()) {
+            if (now - entry.timestamp > this.options.maxAge) {
+                keysToDelete.push(key);
+            }
+        }
+        if (keysToDelete.length > 0) {
+            for (const key of keysToDelete) {
+                this.cache.delete(key);
+            }
+            this.updateStats();
+            this.logger.debug('Expired cache entries cleaned up', {
+                cleanedCount: keysToDelete.length,
+                remainingEntries: this.cache.size,
+                operation: 'cache_cleanup',
+            });
+        }
+    }
+}
+export function generateManifestHash(manifests) {
+    const manifestString = JSON.stringify(manifests, Object.keys(manifests).sort());
+    return hashString(manifestString);
+}
+export function generatePluginHash(plugins, pluginConfigs) {
+    const configString = JSON.stringify({
+        plugins: plugins.sort(),
+        configs: pluginConfigs,
+    }, Object.keys({ plugins: plugins.sort(), configs: pluginConfigs }).sort());
+    return hashString(configString);
+}
+function hashString(str) {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+        hash = (hash << 5) + hash + str.charCodeAt(i);
+    }
+    return Math.abs(hash).toString(36);
+}

package/dist/lib/rutter.d.ts

@@ -2,10 +2,12 @@ import { ApiObject } from 'cdk8s';
 import type { ChartProps } from 'cdk8s';
 import type { Ingress, ServiceAccount } from 'cdk8s-plus-33';
 import type { Construct } from 'constructs';
+import { type SynthAsset } from './helmChartWriter.js';
 import { type TimonelLogger } from './utils/logger.js';
 import type { AWSALBIngressSpec, AWSEBSStorageClassSpec, AWSECRServiceAccountSpec, AWSEFSStorageClassSpec, AWSIRSAServiceAccountSpec } from './resources/cloud/aws/awsResources.js';
 import type { KarpenterEC2NodeClassSpec, KarpenterNodeClaimSpec, KarpenterNodePoolSpec } from './resources/cloud/aws/karpenterResources.js';
 import type { HelperDefinition } from './utils/helmHelpers.js';
+import type { PolicyEngine } from './policy/index.js';
 export declare class Rutter {
     private static readonly HELPER_NAME;
     private readonly app;
@@ -92,8 +94,10 @@ export declare class Rutter {
         yaml: string;
         target: string;
     }>;
-    private toSynthArray;
-    write(outDir: string): void;
+    toSynthArray(): Promise<SynthAsset[]>;
+    toSynthArraySync(): SynthAsset[];
+    private formatPolicyErrors;
+    write(outDir: string): Promise<void>;
 }
 export interface ChartMetadata {
     description?: string;
@@ -117,6 +121,7 @@ export interface RutterProps {
     manifestPrefix?: string;
     meta: ChartMetadata;
     namespace?: string;
+    policyEngine?: PolicyEngine;
     scope?: Construct;
     singleManifestFile?: boolean;
     logger?: TimonelLogger;

package/dist/lib/rutter.js

@@ -8,6 +8,7 @@ import { KarpenterResources } from './resources/cloud/aws/karpenterResources.js'
 import { isHelmExpression, isHelmConstruct } from './utils/helmControlStructures.js';
 import { dumpHelmAwareYaml, preprocessHelmConstructs } from './utils/helmYamlSerializer.js';
 import { generateHelpersTemplate } from './utils/helmHelpers.js';
+const UNKNOWN_ERROR_MESSAGE = 'Unknown error';
 export class Rutter {
     constructor(props) {
         this.assets = [];
@@ -29,6 +30,13 @@ export class Rutter {
         });
         this.awsResources = new AWSResources(this.chart);
         this.karpenterResources = new KarpenterResources(this.chart);
+        const originalToSynthArray = this.toSynthArray.bind(this);
+        this['toSynthArray'] = (..._args) => {
+            if (!this.props.policyEngine) {
+                return this.toSynthArraySync();
+            }
+            return originalToSynthArray();
+        };
     }
     addAWSEBSStorageClass(spec) {
         return this.awsResources.addEBSStorageClass(spec);
@@ -67,7 +75,7 @@ export class Rutter {
                 manifestObject = parse(yamlOrObject);
             }
             catch (error) {
-                throw new Error(`Invalid YAML provided to addManifest(): ${error instanceof Error ? error.message : 'Unknown error'}`);
+                throw new Error(`Invalid YAML provided to addManifest(): ${error instanceof Error ? error.message : UNKNOWN_ERROR_MESSAGE}`);
             }
         }
         else if (typeof yamlOrObject === 'object' && yamlOrObject !== null) {
@@ -126,7 +134,7 @@ ${yamlContent.trim()}
             this.assets.push(conditionalAsset);
         }
         catch (error) {
-            throw new Error(`Failed to generate conditional template for manifest '${id}': ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to generate conditional template for manifest '${id}': ${error instanceof Error ? error.message : UNKNOWN_ERROR_MESSAGE}`);
         }
         return new ApiObject(this.chart, `${id}-placeholder`, {
             apiVersion: manifestObject['apiVersion'],
@@ -190,7 +198,7 @@ ${yamlContent.trim()}
     getAssets() {
         return [...this.assets];
     }
-    toSynthArray() {
+    async toSynthArray() {
         const timer = this.logger.time('chart_synthesis');
         this.logger.debug('Starting chart synthesis', {
             chartName: this.meta.name,
@@ -217,6 +225,51 @@ ${yamlContent.trim()}
             apiObjectCount: apiObjectIds.length,
             operation: 'manifest_processing',
         });
+        if (this.props.policyEngine) {
+            this.logger.debug('Starting policy validation before enrichment', {
+                chartName: this.meta.name,
+                manifestCount: manifestObjs.length,
+                operation: 'policy_validation_start',
+            });
+            try {
+                const validationResult = await this.props.policyEngine.validate(manifestObjs, this.meta);
+                if (!validationResult.valid) {
+                    const errorMessage = this.formatPolicyErrors(validationResult);
+                    this.logger.error('Policy validation failed', {
+                        chartName: this.meta.name,
+                        violationCount: validationResult.violations.length,
+                        operation: 'policy_validation_failed',
+                    });
+                    throw new Error(`Policy validation failed: ${errorMessage}`);
+                }
+                if (validationResult.warnings.length > 0) {
+                    this.logger.warn('Policy validation warnings', {
+                        chartName: this.meta.name,
+                        warningCount: validationResult.warnings.length,
+                        warnings: validationResult.warnings.map((w) => ({
+                            plugin: w.plugin,
+                            message: w.message,
+                            severity: w.severity,
+                        })),
+                        operation: 'policy_validation_warnings',
+                    });
+                }
+                this.logger.info('Policy validation completed successfully before enrichment', {
+                    chartName: this.meta.name,
+                    pluginCount: validationResult.metadata.pluginCount,
+                    executionTime: validationResult.metadata.executionTime,
+                    operation: 'policy_validation_success',
+                });
+            }
+            catch (error) {
+                this.logger.error('Policy validation error', {
+                    chartName: this.meta.name,
+                    error: error instanceof Error ? error.message : UNKNOWN_ERROR_MESSAGE,
+                    operation: 'policy_validation_error',
+                });
+                throw error;
+            }
+        }
         const enriched = manifestObjs.map((obj) => {
             const preprocessed = preprocessHelmConstructs(obj);
             if (preprocessed && typeof preprocessed === 'object') {
@@ -247,7 +300,7 @@ ${yamlContent.trim()}
                 .filter(Boolean)
                 .join('\n---\n');
             const manifestId = this.props.manifestPrefix ?? 'manifests';
-            synthAssets.push({ id: manifestId, yaml: combinedYaml });
+            synthAssets.push({ id: manifestId, yaml: combinedYaml, target: 'templates' });
         }
         else {
             enriched.forEach((obj, index) => {
@@ -255,12 +308,16 @@ ${yamlContent.trim()}
                 const manifestId = apiObjectId || `manifest-${index + 1}`;
                 const yaml = dumpHelmAwareYaml(obj).trim();
                 if (yaml) {
-                    synthAssets.push({ id: manifestId, yaml });
+                    synthAssets.push({ id: manifestId, yaml, target: 'templates' });
                 }
             });
         }
         this.assets.forEach((asset) => {
-            synthAssets.push({ id: asset.id, yaml: asset.yaml });
+            synthAssets.push({
+                id: asset.id,
+                yaml: asset.yaml,
+                target: asset.target || 'templates',
+            });
         });
         this.logger.info('Chart synthesis completed', {
             chartName: this.meta.name,
@@ -271,7 +328,119 @@ ${yamlContent.trim()}
         timer();
         return synthAssets;
     }
-    write(outDir) {
+    toSynthArraySync() {
+        if (this.props.policyEngine) {
+            throw new Error('toSynthArraySync() cannot be used with policy engine. Use toSynthArray() instead.');
+        }
+        const timer = this.logger.time('chart_synthesis_sync');
+        this.logger.debug('Starting synchronous chart synthesis', {
+            chartName: this.meta.name,
+            operation: 'synthesis_start_sync',
+        });
+        const apiObjectIds = [];
+        for (const child of this.chart.node.children) {
+            if (child instanceof ApiObject && !child.node.id.endsWith('-placeholder')) {
+                apiObjectIds.push(child.node.id);
+            }
+        }
+        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;
+        });
+        this.logger.info('Processing manifest objects synchronously', {
+            chartName: this.meta.name,
+            manifestCount: manifestObjs.length,
+            apiObjectCount: apiObjectIds.length,
+            operation: 'manifest_processing_sync',
+        });
+        const enriched = manifestObjs.map((obj) => {
+            const preprocessed = preprocessHelmConstructs(obj);
+            if (preprocessed && typeof preprocessed === 'object') {
+                const o = preprocessed;
+                o.metadata = o.metadata ?? {};
+                o.metadata.labels = o.metadata.labels ?? {};
+                const labels = o.metadata.labels;
+                const defaults = {
+                    'helm.sh/chart': `{{ .Chart.Name }}-{{ .Chart.Version }}`,
+                    'app.kubernetes.io/name': include(Rutter.HELPER_NAME),
+                    'app.kubernetes.io/instance': '{{ .Release.Name }}',
+                    'app.kubernetes.io/version': '{{ .Chart.Version }}',
+                    'app.kubernetes.io/managed-by': '{{ .Release.Service }}',
+                    'app.kubernetes.io/part-of': '{{ .Chart.Name }}',
+                };
+                for (const [key, value] of Object.entries(defaults)) {
+                    if (!(key in labels)) {
+                        labels[key] = value;
+                    }
+                }
+            }
+            return preprocessed;
+        });
+        const synthAssets = [];
+        if (this.props.singleManifestFile) {
+            const combinedYaml = enriched
+                .map((obj) => dumpHelmAwareYaml(obj).trim())
+                .filter(Boolean)
+                .join('\n---\n');
+            const manifestId = this.props.manifestPrefix ?? 'manifests';
+            synthAssets.push({ id: manifestId, yaml: combinedYaml, target: 'templates' });
+        }
+        else {
+            enriched.forEach((obj, index) => {
+                const apiObjectId = apiObjectIds[index];
+                const manifestId = apiObjectId || `manifest-${index + 1}`;
+                const yaml = dumpHelmAwareYaml(obj).trim();
+                if (yaml) {
+                    synthAssets.push({ id: manifestId, yaml, target: 'templates' });
+                }
+            });
+        }
+        this.assets.forEach((asset) => {
+            synthAssets.push({
+                id: asset.id,
+                yaml: asset.yaml,
+                target: asset.target || 'templates',
+            });
+        });
+        this.logger.info('Synchronous chart synthesis completed', {
+            chartName: this.meta.name,
+            totalAssets: synthAssets.length,
+            additionalAssets: this.assets.length,
+            operation: 'synthesis_complete_sync',
+        });
+        timer();
+        return synthAssets;
+    }
+    formatPolicyErrors(result) {
+        const errorMessages = [];
+        if (result.violations && result.violations.length > 0) {
+            errorMessages.push(`Found ${result.violations.length} policy violation(s):`);
+            result.violations.forEach((violation, index) => {
+                const parts = [`${index + 1}. [${violation.plugin}] ${violation.message}`];
+                if (violation.resourcePath) {
+                    parts.push(`Resource: ${violation.resourcePath}`);
+                }
+                if (violation.field) {
+                    parts.push(`Field: ${violation.field}`);
+                }
+                if (violation.suggestion) {
+                    parts.push(`Suggestion: ${violation.suggestion}`);
+                }
+                errorMessages.push(`   ${parts.join(' | ')}`);
+            });
+        }
+        if (result.summary) {
+            const summary = result.summary;
+            errorMessages.push(`Summary: ${summary.violationsBySeverity.error} error(s), ${summary.violationsBySeverity.warning} warning(s), ${summary.violationsBySeverity.info} info(s)`);
+        }
+        return errorMessages.join('\n');
+    }
+    async write(outDir) {
         const timer = this.logger.time('chart_write');
         this.logger.info('Starting chart write operation', {
             chartName: this.meta.name,
@@ -297,7 +466,7 @@ ${helper.template}
         else {
             helpersContent = generateHelpersTemplate(this.props.cloudProvider);
         }
-        const synthAssets = this.toSynthArray();
+        const synthAssets = await this.toSynthArray();
         this.logger.info('Generated assets for chart', {
             chartName: this.meta.name,
             assetCount: synthAssets.length,

package/dist/lib/templates/flexible-subchart.js

@@ -204,8 +204,10 @@ export default function createChart() {
 
 // Auto-execute when run directly
 if (import.meta.url === new URL(import.meta.url).href) {
-  const chart = createChart();
-  chart.write('dist');
+  (async () => {
+    const chart = createChart();
+    await chart.write('dist');
+  })();
 }
 `;
 }

package/dist/lib/templates/umbrella-chart.js

@@ -47,7 +47,7 @@ function readYamlFile(filePath: string): Record<string, unknown> {
   return content && typeof content === 'object' ? (content as Record<string, unknown>) : {};
 }
 
-export function synth(outDir: string, options?: SynthOptions) {
+export async function synth(outDir: string, options?: SynthOptions) {
   const mode = resolveMode(options);
   const app = new App({
     outdir: outDir,
@@ -82,7 +82,7 @@ export function synth(outDir: string, options?: SynthOptions) {
     'namespace',
   );
 
-  umbrella.write(outDir);
+  await umbrella.write(outDir);
 
   const chartPath = join(outDir, 'Chart.yaml');
   const valuesPath = join(outDir, 'values.yaml');
@@ -98,11 +98,11 @@ export function synth(outDir: string, options?: SynthOptions) {
 
     const dependencies: Array<{ name: string; version: string; repository: string }> = [];
 
-    SUBCHARTS.forEach((subchart) => {
+    for (const subchart of SUBCHARTS) {
       const instance = subchart.factory();
       const targetDir = join(chartsDir, subchart.name);
       rmSync(targetDir, { recursive: true, force: true });
-      instance.write(targetDir);
+      await instance.write(targetDir);
       const meta = instance.getMeta();
       const version = meta.version ?? '0.1.0';
       dependencies.push({
@@ -114,7 +114,7 @@ export function synth(outDir: string, options?: SynthOptions) {
       if (Object.keys(subchartValues).length > 0) {
         valuesDoc[subchart.name] = subchartValues;
       }
-    });
+    }
 
     chartDoc.dependencies = dependencies;
   } else {
@@ -124,11 +124,11 @@ export function synth(outDir: string, options?: SynthOptions) {
     }
     delete chartDoc.dependencies;
 
-    SUBCHARTS.forEach((subchart) => {
+    for (const subchart of SUBCHARTS) {
       const instance = subchart.factory();
       const tempDir = join(outDir, '.timonel-inline-' + subchart.name);
       rmSync(tempDir, { recursive: true, force: true });
-      instance.write(tempDir);
+      await instance.write(tempDir);
 
       const subTemplatesDir = join(tempDir, 'templates');
       if (existsSync(subTemplatesDir)) {
@@ -145,7 +145,7 @@ export function synth(outDir: string, options?: SynthOptions) {
       }
 
       rmSync(tempDir, { recursive: true, force: true });
-    });
+    }
   }
 
   writeFileSync(chartPath, stringify(chartDoc));

package/dist/lib/umbrellaRutter.d.ts

@@ -21,7 +21,7 @@ export declare class UmbrellaRutter {
     private readonly logger;
     constructor(props: UmbrellaRutterProps);
     private validateMetadata;
-    write(outDir: string): void;
+    write(outDir: string): Promise<void>;
     private writeParentChart;
     private writeParentValues;
     private deepMerge;

package/dist/lib/umbrellaRutter.js

@@ -22,7 +22,7 @@ export class UmbrellaRutter {
             throw new Error('Chart version must follow semantic versioning (e.g., 1.0.0)');
         }
     }
-    write(outDir) {
+    async write(outDir) {
         const validatedOutDir = SecurityUtils.validatePath(outDir, process.cwd(), {
             allowAbsolute: true,
         });
@@ -37,7 +37,7 @@ export class UmbrellaRutter {
             }
             const sanitizedName = subchart.name;
             const subchartDir = SecurityUtils.validatePath(join(validatedOutDir, 'charts', sanitizedName), process.cwd(), { allowAbsolute: true });
-            subchart.rutter.write(subchartDir);
+            await subchart.rutter.write(subchartDir);
         }
         this.writeParentChart(validatedOutDir);
         this.writeParentValues(validatedOutDir);