typekro 0.43.0 → 0.44.1

package/dist/core/expressions/analysis/fn-toString-self-test.d.ts

@@ -1,146 +0,0 @@
-/**
- * fn.toString() Self-Test
- *
- * TypeKro relies on `fn.toString()` producing parseable JavaScript source code in
- * multiple critical code paths (status builder analysis, composition body analysis,
- * imperative composition analysis, readyWhen callback conversion, and expression
- * classification). This module provides a self-test that verifies the current runtime
- * environment produces parseable output.
- *
- * ## Why this matters
- *
- * The `Function.prototype.toString()` output varies by runtime and build configuration:
- *
- * | Environment              | Arrow function toString()                     | Parseable? |
- * |--------------------------|-----------------------------------------------|------------|
- * | Node.js / Bun (no build) | `(x) => x + 1`                               | Yes        |
- * | Bun (transpiled)         | `(x) => x + 1` (quotes normalized to double)  | Yes        |
- * | esbuild (minified)       | `x=>x+1` (whitespace removed)                 | Yes        |
- * | esbuild (mangled)        | `a=>a+1` (names mangled)                      | Partial*   |
- * | Terser (mangled)         | `a=>a+1`                                      | Partial*   |
- * | Webpack mode=production  | May inline or remove function bodies            | No         |
- * | Closure Compiler ADVANCED | Removes/renames everything                    | No         |
- *
- * *Partial: AST parses, but parameter names are mangled so `schema.spec.name`
- * becomes `a.spec.name` — the composition analyzer needs the original names.
- *
- * ## Build configurations that break TypeKro
- *
- * 1. **Variable name mangling** (`esbuild --mangle`, `terser --mangle-props`):
- *    Renames function parameters. Status builder analysis depends on parameter names
- *    matching resource keys (e.g., `(schema, resources) => ...`).
- *
- * 2. **Dead code elimination** with tree-shaking that removes function bodies:
- *    The composition analyzer needs the full function body to detect if/for/ternary
- *    patterns.
- *
- * 3. **Advanced minification** (Closure Compiler ADVANCED, UglifyJS with `compress`):
- *    May restructure control flow, inline functions, or evaluate expressions at
- *    compile time, making the source unparseable or semantically different.
- *
- * 4. **Source-to-source transforms** that don't preserve function structure:
- *    SWC with certain plugins, Babel transforms that rewrite arrow functions to
- *    regular functions with different parameter patterns.
- *
- * ## Safe configurations
- *
- * - **No bundler** (direct TypeScript execution via Bun or ts-node): Always works
- * - **esbuild with `--minify-whitespace` only** (no `--mangle`): Works
- * - **Webpack mode=development**: Works
- * - **Vite dev mode**: Works
- * - **Any bundler with `Function.prototype.toString` polyfill that preserves source**: Works
- *
- * ## Call sites that depend on fn.toString()
- *
- * | File                                | Usage                                    |
- * |-------------------------------------|------------------------------------------|
- * | `serialization/yaml.ts`             | readyWhen callback → CEL conversion      |
- * | `deployment/debug-logger.ts`        | Evaluator type inspection (non-critical) |
- * | `expressions/factory/status-builder-analyzer.ts` | Status builder AST parsing    |
- * | `expressions/context/context-detector.ts`        | Expression complexity analysis|
- * | `expressions/analysis/expression-classifier.ts`  | Function body analysis        |
- * | `expressions/composition/composition-analyzer.ts` | Composition body detection   |
- * | `expressions/composition/imperative-analyzer.ts`  | Imperative composition parse |
- * | `expressions/composition/expression-analyzer.ts`  | Pattern detection            |
- *
- * ## Future alternative: TypeScript Compiler API
- *
- * As an opt-in alternative to `fn.toString()` + acorn parsing, the TypeScript Compiler
- * API (`typescript` package) could be used to analyze user-supplied functions at build
- * time or at schema-registration time. This would eliminate the runtime dependency on
- * `fn.toString()` producing parseable output entirely.
- *
- * ### How it would work
- *
- * 1. **At `toResourceGraph()` call time**, capture the source file path and position of
- *    the status builder / composition function using `Error().stack` or a build plugin.
- * 2. **Use `ts.createProgram()`** to parse the original TypeScript source (not the
- *    transpiled output) with full type information.
- * 3. **Walk the AST** using `ts.forEachChild()` to find the function node at the
- *    captured position and extract parameter types, return types, and body structure.
- * 4. **Cache results** keyed by file path + position so re-analysis is free.
- *
- * ### Advantages
- *
- * - Works regardless of bundler/minifier configuration
- * - Has access to full TypeScript type information (not just runtime values)
- * - Can detect type errors in status builders at registration time
- * - No runtime `fn.toString()` calls needed
- *
- * ### Challenges (estimated 2+ weeks to implement)
- *
- * - **Source location capture**: Reliably mapping a runtime function call back to its
- *   source file position is non-trivial. `Error().stack` line numbers may not match
- *   original TS source after transpilation. A build plugin (Bun plugin, esbuild plugin)
- *   could inject source locations at compile time.
- * - **TypeScript as a dependency**: The `typescript` package is ~45MB. It should be an
- *   optional peer dependency, loaded dynamically with `import('typescript')`.
- * - **Performance**: `ts.createProgram()` is expensive (~500ms-2s for a medium project).
- *   Must be lazy and cached. Could use `ts.createLanguageService()` for incremental
- *   parsing.
- * - **Monorepo / workspace support**: Source files may be in different packages with
- *   different tsconfig.json files. The API would need to resolve the correct config.
- * - **Runtime-only environments**: Users running TypeKro without access to source files
- *   (e.g., in a Docker container with only compiled JS) would still need the
- *   `fn.toString()` fallback.
- * - **Test coverage**: All 12 call sites would need dual-path testing (TS API path +
- *   fn.toString() fallback path).
- *
- * ### Recommendation
- *
- * Keep `fn.toString()` as the default path with the self-test as a safety net. The TS
- * Compiler API approach should be a future opt-in for users who need bundler-safe
- * analysis. Implementation should wait until there is concrete user demand from a
- * production deployment that uses aggressive minification.
- */
-export interface FnToStringSelfTestResult {
-    /** Whether the runtime produces parseable fn.toString() output */
-    parseable: boolean;
-    /** Whether parameter names are preserved (not mangled) */
-    parameterNamesPreserved: boolean;
-    /** Whether function bodies are preserved (not stripped) */
-    functionBodiesPreserved: boolean;
-    /** Whether arrow function syntax is preserved */
-    arrowSyntaxPreserved: boolean;
-    /** Overall: is the environment compatible with TypeKro's analysis features? */
-    compatible: boolean;
-    /** Detailed diagnostics */
-    diagnostics: string[];
-}
-/**
- * Run the fn.toString() self-test.
- *
- * Call this early in the application lifecycle to detect incompatible
- * build configurations before they cause subtle analysis failures.
- *
- * @returns Self-test results with compatibility assessment
- */
-export declare function runFnToStringSelfTest(): FnToStringSelfTestResult;
-/**
- * Validate the runtime environment and log warnings if fn.toString() analysis
- * will not work correctly. This is a no-op if the environment is compatible.
- *
- * Call once during application initialization.
- */
-export declare function validateFnToStringEnvironment(): void;
-//# sourceMappingURL=fn-toString-self-test.d.ts.map

package/dist/core/expressions/analysis/fn-toString-self-test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"fn-toString-self-test.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/fn-toString-self-test.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkHG;AAuBH,MAAM,WAAW,wBAAwB;IACvC,kEAAkE;IAClE,SAAS,EAAE,OAAO,CAAC;IACnB,0DAA0D;IAC1D,uBAAuB,EAAE,OAAO,CAAC;IACjC,2DAA2D;IAC3D,uBAAuB,EAAE,OAAO,CAAC;IACjC,iDAAiD;IACjD,oBAAoB,EAAE,OAAO,CAAC;IAC9B,+EAA+E;IAC/E,UAAU,EAAE,OAAO,CAAC;IACpB,2BAA2B;IAC3B,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,IAAI,wBAAwB,CA6EhE;AAED;;;;;GAKG;AACH,wBAAgB,6BAA6B,IAAI,IAAI,CA6BpD"}

package/dist/core/expressions/analysis/operator-utils.d.ts

@@ -1,35 +0,0 @@
-/**
- * Operator mapping, precedence, and boolean-test utilities.
- *
- * All functions are pure (stateless) – extracted from JavaScriptToCelAnalyzer
- * to reduce the class to a slim orchestrator.
- */
-/** Map a JavaScript logical/comparison operator to its CEL equivalent. */
-export declare function mapOperatorToCel(operator: string): string;
-/** Map a JavaScript binary operator (including arithmetic) to CEL. Throws for unsupported ops. */
-export declare function convertBinaryOperator(operator: string): string;
-/** Get numeric precedence for an operator (lower = binds less tightly). */
-export declare function getOperatorPrecedence(operator: string): number;
-/** Whether an operator is left-associative. Ternary (`?`) is the only right-associative one. */
-export declare function isLeftAssociative(operator: string): boolean;
-/**
- * Find the "main" (lowest-precedence) operator at depth-0 in an expression string.
- */
-export declare function getMainOperator(expression: string): string | null;
-/**
- * Wrap `expression` in parentheses when its main operator has lower precedence
- * than `parentOperator`, or when it is a right operand with equal precedence
- * for left-associative operators.
- */
-export declare function addParenthesesIfNeeded(expression: string, parentOperator?: string, isLeftOperand?: boolean): string;
-/** Check whether an expression string already contains a boolean comparison. */
-export declare function isBooleanExpression(expression: string): boolean;
-/**
- * Convert a CEL expression to a boolean test.
- * If the expression is already boolean, return it unchanged;
- * otherwise wrap it in truthy-check conditions.
- */
-export declare function convertToBooleanTest(expression: string): string;
-/** Infer a representative zero-value from a Kubernetes field path. */
-export declare function inferTypeFromFieldPath(fieldPath: string): string | number | boolean | Record<string, unknown> | unknown[];
-//# sourceMappingURL=operator-utils.d.ts.map

package/dist/core/expressions/analysis/operator-utils.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"operator-utils.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/operator-utils.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAmBH,0EAA0E;AAC1E,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAEzD;AAkBD,kGAAkG;AAClG,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAU9D;AAsBD,2EAA2E;AAC3E,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED,gGAAgG;AAChG,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAE3D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CA4BjE;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,MAAM,EAClB,cAAc,CAAC,EAAE,MAAM,EACvB,aAAa,CAAC,EAAE,OAAO,GACtB,MAAM,CAiBR;AAID,gFAAgF;AAChF,wBAAgB,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAG/D;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAG/D;AAID,sEAAsE;AACtE,wBAAgB,sBAAsB,CACpC,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,EAAE,CA6BjE"}

package/dist/core/expressions/analysis/ready-when.d.ts

@@ -1,3 +0,0 @@
-/** Lower the supported readyWhen callback subset into a CEL expression. */
-export declare function convertReadyWhenCallbackToCel(fn: (...args: unknown[]) => unknown, resourceId: string): string;
-//# sourceMappingURL=ready-when.d.ts.map

package/dist/core/expressions/analysis/ready-when.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"ready-when.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/ready-when.ts"],"names":[],"mappings":"AAgGA,2EAA2E;AAC3E,wBAAgB,6BAA6B,CAC3C,EAAE,EAAE,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,OAAO,EACnC,UAAU,EAAE,MAAM,GACjB,MAAM,CA0BR"}

package/dist/core/expressions/analysis/scope-resolver.d.ts

@@ -1,57 +0,0 @@
-/**
- * Scope Resolver — Dependency extraction and resource reference resolution
- *
- * Extracted from analyzer.ts. Contains all methods that extract KubernetesRef
- * dependencies from expression strings, resolve resource/schema references,
- * and generate CEL field paths from KubernetesRef objects.
- */
-import type { CelExpression, KubernetesRef } from '../../types/common.js';
-import type { Enhanced } from '../../types/kubernetes.js';
-import type { SchemaProxy } from '../../types/serialization.js';
-import type { AnalysisContext, CelConversionResult } from './shared-types.js';
-export { isResourceReference } from './cel-emitter.js';
-/**
- * Generate CEL expression from KubernetesRef based on context.
- * Handles the core KubernetesRef to CEL field path conversion (resourceId.fieldPath).
- */
-export declare function generateCelFromKubernetesRef(ref: KubernetesRef<unknown>, context: AnalysisContext): string;
-/**
- * Convert a KubernetesRef directly to a CEL expression.
- * This is the main method for KubernetesRef to CEL field path conversion.
- */
-export declare function convertKubernetesRefToCel(ref: KubernetesRef<unknown>, context: AnalysisContext, typeValidator?: {
-    validateKubernetesRef: (ref: KubernetesRef<unknown>, availableReferences: Record<string, Enhanced<unknown, unknown>>, schemaProxy?: SchemaProxy<Record<string, unknown>, Record<string, unknown>>) => {
-        valid: boolean;
-        errors: {
-            message: string;
-        }[];
-    };
-}): CelExpression;
-/**
- * Extract resource reference strings from an expression.
- * Returns array of strings like "deployment.status.readyReplicas".
- */
-export declare function extractResourceReferencesFromExpression(expression: string): string[];
-/**
- * Extract dependencies from JavaScript expression string and return them.
- * Looks for resource references and schema references in the expression text.
- */
-export declare function extractDependenciesFromExpressionString(expression: string, context: AnalysisContext): KubernetesRef<unknown>[];
-/**
- * Extract dependencies from JavaScript expression and add them to context.dependencies.
- * This is the mutation-based variant used by the special case handlers.
- */
-export declare function extractDependenciesFromExpression(expression: string, context: AnalysisContext): void;
-/**
- * Handle optional chaining expressions.
- */
-export declare function handleOptionalChainingExpression(expression: string, context: AnalysisContext): CelConversionResult;
-/**
- * Handle expressions with both optional chaining and nullish coalescing.
- */
-export declare function handleMixedOptionalAndNullishExpression(expression: string, context: AnalysisContext): CelConversionResult;
-/**
- * Handle nullish coalescing expressions.
- */
-export declare function handleNullishCoalescingExpression(expression: string, context: AnalysisContext): CelConversionResult;
-//# sourceMappingURL=scope-resolver.d.ts.map

package/dist/core/expressions/analysis/scope-resolver.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"scope-resolver.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/scope-resolver.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,OAAO,KAAK,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAC1E,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,8BAA8B,CAAC;AAGhE,OAAO,KAAK,EAAE,eAAe,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAI9E,OAAO,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAC;AAIvD;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,GAAG,EAAE,aAAa,CAAC,OAAO,CAAC,EAC3B,OAAO,EAAE,eAAe,GACvB,MAAM,CAwBR;AAID;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,GAAG,EAAE,aAAa,CAAC,OAAO,CAAC,EAC3B,OAAO,EAAE,eAAe,EACxB,aAAa,CAAC,EAAE;IACd,qBAAqB,EAAE,CACrB,GAAG,EAAE,aAAa,CAAC,OAAO,CAAC,EAC3B,mBAAmB,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,EAC/D,WAAW,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,KACxE;QAAE,KAAK,EAAE,OAAO,CAAC;QAAC,MAAM,EAAE;YAAE,OAAO,EAAE,MAAM,CAAA;SAAE,EAAE,CAAA;KAAE,CAAC;CACxD,GACA,aAAa,CAsCf;AAID;;;GAGG;AACH,wBAAgB,uCAAuC,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,EAAE,CAcpF;AAID;;;GAGG;AACH,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,aAAa,CAAC,OAAO,CAAC,EAAE,CAiE1B;AAID;;;GAGG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,IAAI,CAuJN;AAID;;GAEG;AACH,wBAAgB,gCAAgC,CAC9C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,mBAAmB,CAoErB;AAED;;GAEG;AACH,wBAAgB,uCAAuC,CACrD,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,mBAAmB,CAmErB;AAED;;GAEG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,eAAe,GACvB,mBAAmB,CAmErB"}

package/dist/core/expressions/analysis/strict-cel.d.ts

@@ -1,26 +0,0 @@
-/**
- * Strict CEL diagnostics mode resolution.
- *
- * When the JS→CEL analyzer cannot prove an emitted CEL expression
- * type-checks (e.g. a member expression references a resource that is not
- * part of the resource graph), the default behavior is lenient: emit the
- * expression anyway and log a warning. The failure then only surfaces when
- * KRO rejects the ResourceGraphDefinition on a live cluster — potentially
- * long after serialization.
- *
- * In strict mode the conversion throws at analysis/serialization time with
- * the offending expression instead.
- *
- * Strictness is resolved from (highest precedence first):
- *   1. An explicit `strictCelDiagnostics` flag (on the `AnalysisContext`, or
- *      threaded from factory options such as
- *      `.factory('kro', { strictCelDiagnostics: true })`).
- *   2. The `TYPEKRO_STRICT_CEL` environment variable (`1` or `true`).
- *
- * The environment variable is consulted ONLY here so the global default is
- * defined in a single place rather than scattered across diagnostic sites.
- */
-export declare function isStrictCelDiagnosticsEnabled(context?: {
-    strictCelDiagnostics?: boolean | undefined;
-}): boolean;
-//# sourceMappingURL=strict-cel.d.ts.map

package/dist/core/expressions/analysis/strict-cel.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"strict-cel.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/strict-cel.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE;IACtD,oBAAoB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;CAC5C,GAAG,OAAO,CAMV"}

package/dist/core/expressions/analysis/string-method-converters.d.ts

@@ -1,27 +0,0 @@
-/**
- * JavaScript string method → CEL expression converters.
- *
- * Each function converts a specific JS string method call to its CEL equivalent.
- * All functions are stateless – they receive a `convertNode` callback for recursion.
- */
-import type { Expression as ESTreeExpression, SpreadElement as ESTreeSpreadElement } from 'estree';
-import type { CelExpression } from '../../types/common.js';
-import type { AnalysisContext, ConvertNodeFn } from './shared-types.js';
-type Args = readonly (ESTreeExpression | ESTreeSpreadElement)[];
-export declare function convertStringIncludes(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringStartsWith(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringEndsWith(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringToLowerCase(object: CelExpression, args: Args, _context: AnalysisContext): CelExpression;
-export declare function convertStringToUpperCase(object: CelExpression, args: Args, _context: AnalysisContext): CelExpression;
-export declare function convertStringTrim(object: CelExpression, args: Args, _context: AnalysisContext): CelExpression;
-export declare function convertStringSubstring(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringSlice(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringSplit(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringPadStart(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringPadEnd(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringRepeat(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringReplace(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringIndexOf(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export declare function convertStringLastIndexOf(object: CelExpression, args: Args, context: AnalysisContext, convertNode: ConvertNodeFn): CelExpression;
-export {};
-//# sourceMappingURL=string-method-converters.d.ts.map

package/dist/core/expressions/analysis/string-method-converters.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"string-method-converters.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/analysis/string-method-converters.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,UAAU,IAAI,gBAAgB,EAAE,aAAa,IAAI,mBAAmB,EAAE,MAAM,QAAQ,CAAC;AAInG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AAExE,KAAK,IAAI,GAAG,SAAS,CAAC,gBAAgB,GAAG,mBAAmB,CAAC,EAAE,CAAC;AAIhE,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,eAAe,GACxB,aAAa,CAaf;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,eAAe,GACxB,aAAa,CAaf;AAID,wBAAgB,iBAAiB,CAC/B,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,QAAQ,EAAE,eAAe,GACxB,aAAa,CAaf;AAID,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAsBf;AAID,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAsBf;AAID,wBAAgB,kBAAkB,CAChC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAgBf;AAID,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAgBf;AAID,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAef;AAID,wBAAgB,oBAAoB,CAClC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf;AAID,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,eAAe,EACxB,WAAW,EAAE,aAAa,GACzB,aAAa,CAcf"}

package/dist/core/expressions/composition/composition-analyzer-helpers.d.ts

@@ -1,114 +0,0 @@
-/**
- * Stateless utility functions for the composition body analyzer.
- *
- * Used by both ternary analysis and AST traversal modules.
- */
-import { type LexicalAliasScope } from '../analysis/alias-inliner.js';
-import type { ASTNode, CallExpression, FactoryCallInfo } from './composition-analyzer-types.js';
-/**
- * Extract source text from an AST node using character ranges.
- */
-export declare function getSource(node: ASTNode, fullSource: string): string;
-/**
- * Check if a CallExpression is a factory call (Deployment, ConfigMap, Service, etc.)
- * by looking at the callee name against the central FactoryRegistry.
- *
- * Custom factories become first-class by calling `registerFactory()` at import
- * time — no need to edit this file.
- */
-export declare function isFactoryCall(node: ASTNode): node is CallExpression;
-/** Extract the factory function name from a factory call expression */
-export declare function extractFactoryName(call: CallExpression): string;
-/**
- * Extract the `id` property value from factory call arguments.
- *
- * Factory calls like `Deployment({ name: ..., id: 'web' })` have
- * an ObjectExpression as their first argument containing the id property.
- */
-export declare function extractFactoryId(call: CallExpression): string | undefined;
-export declare function conditionToCel(node: ASTNode, fullSource: string, specParamName: string, optionalFieldNames?: Set<string>, lexicalAliases?: LexicalAliasScope): string;
-/**
- * Convert an iterable source expression to a Kro forEach CEL reference.
- *
- * e.g. `spec.regions` → `${schema.spec.regions}`
- * e.g. `spec.workers.filter(w => w.enabled)` → `${schema.spec.workers.filter(w, w.enabled)}`
- */
-export declare function iterableToCel(node: ASTNode, fullSource: string, specParamName: string): string;
-/**
- * Check if a condition node is a compile-time literal (e.g. `true`, `false`, `1`).
- * Compile-time literals should NOT produce includeWhen directives.
- */
-export declare function isCompileTimeLiteral(node: ASTNode): boolean;
-/**
- * Check if a condition references the schema spec parameter.
- * Only conditions that reference schema fields should produce includeWhen.
- */
-export declare function referencesSpec(node: ASTNode, specParamName: string): boolean;
-/**
- * Check if an expression references a resource's status field — i.e.,
- * contains a `<identifier>.status.<field>` MemberExpression where the
- * root identifier is NOT the spec parameter and NOT a known JS global.
- *
- * Returns the `{ variableName, statusField }` if found, or `undefined`.
- * Used by the ternary detector to widen its gate beyond spec-only conditions.
- *
- * **Limitation — compound conditions**: Returns on the first match
- * (`VisitorOption.Break`). For compound expressions like
- * `cache.status.ready && db.status.instances >= 1`, only the first
- * status ref (`cache.status.ready`) is captured. The inverted run
- * then flips only that field, which may not fully invert the ternary
- * if the second condition also contributes. This is acceptable for
- * now: compound resource-status ternaries are rare, and `dependsOn`
- * + `Cel.cond` can handle them explicitly.
- */
-export declare function extractResourceStatusRef(node: ASTNode, specParamName: string, optionalFieldNames?: Set<string>): {
-    variableName: string;
-    statusField: string;
-    conditionExpression?: string;
-} | undefined;
-/**
- * Rewrite every `<jsVariable>.status.` reference in a CEL-ish condition to its
- * serialized KRO resource ID. Compound conditions can reference more than the
- * primary variable captured by `extractResourceStatusRef`.
- */
-export declare function remapResourceStatusReferences(conditionExpression: string, variableToResourceId: Map<string, string>): string;
-/**
- * Find all factory calls in a subtree and return their resource IDs and factory names.
- */
-export declare function findFactoryCallsInSubtree(node: ASTNode): FactoryCallInfo[];
-/**
- * Extract the spec parameter name from the composition function source.
- *
- * Handles patterns:
- *   (spec) => { ... }
- *   function(spec) { ... }
- *   (spec) => expr
- */
-export declare function extractSpecParamName(functionSource: string): string;
-/**
- * Convert a full expression AST node to a CEL string (not just conditions).
- *
- * Reuses the same transforms as conditionToCel:
- * - `spec.` → `schema.spec.`
- * - `===` → `==`, `!==` → `!=`
- * - Single quotes → double quotes
- * - Wraps in `${}`
- */
-export declare function expressionToCel(node: ASTNode, fullSource: string, specParamName: string, optionalFieldNames?: Set<string>, lexicalAliases?: LexicalAliasScope): string;
-/**
- * Map a factory argument property key name to its template property path.
- *
- * Factory arguments like `{ name: ..., image: ..., replicas: ... }` map to
- * template paths like `spec.replicas`. Special keys are mapped differently:
- * - `name` → `metadata.name`
- * - `id` → skipped (internal, not a template property)
- * - Everything else → `spec.{key}`
- */
-export declare function factoryArgKeyToTemplatePath(key: string): string | undefined;
-/**
- * Negate a CEL condition expression.
- *
- * `${schema.spec.monitoring}` → `${!schema.spec.monitoring}`
- */
-export declare function negateCondition(condition: string): string;
-//# sourceMappingURL=composition-analyzer-helpers.d.ts.map

package/dist/core/expressions/composition/composition-analyzer-helpers.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composition-analyzer-helpers.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/composition/composition-analyzer-helpers.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAMH,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,8BAA8B,CAAC;AACtC,OAAO,KAAK,EACV,OAAO,EACP,cAAc,EACd,eAAe,EAIhB,MAAM,iCAAiC,CAAC;AAsEzC;;GAEG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,GAAG,MAAM,CAMnE;AAMD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,cAAc,CAgBnE;AAED,uEAAuE;AACvE,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,CAW/D;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,cAAc,GAAG,MAAM,GAAG,SAAS,CAqBzE;AAuFD,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,cAAc,CAAC,EAAE,iBAAiB,GACjC,MAAM,CA4MR;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,CA8B9F;AAMD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,OAAO,GAAG,OAAO,CAQ3D;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,OAAO,CAe5E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,OAAO,EACb,aAAa,EAAE,MAAM,EACrB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,GAC/B;IAAE,YAAY,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAC;IAAC,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CA0KzF;AAED;;;;GAIG;AACH,wBAAgB,6BAA6B,CAC3C,mBAAmB,EAAE,MAAM,EAC3B,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GACxC,MAAM,CAQR;AAMD;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,OAAO,GAAG,eAAe,EAAE,CAkB1E;AAMD;;;;;;;GAOG;AACH,wBAAgB,oBAAoB,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAYnE;AAMD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,cAAc,CAAC,EAAE,iBAAiB,GACjC,MAAM,CAER;AAED;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAY3E;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAIzD"}

package/dist/core/expressions/composition/composition-analyzer-ternary.d.ts

@@ -1,78 +0,0 @@
-/**
- * Ternary detection and collection aggregate analysis for the composition analyzer.
- *
- * Handles:
- * - Ternary expressions in factory arguments → CEL conditionals in templates
- * - Ternary expressions in return statements → CEL conditionals in status
- * - Collection aggregate patterns (`.map().length`, `.every()`, `.some()`, etc.)
- */
-import type { LexicalAliasScope } from '../analysis/alias-inliner.js';
-import type { ASTAnalysisResult, ASTNode, CallExpression, CollectionVariable } from './composition-analyzer-types.js';
-/**
- * Scan a factory call's ObjectExpression argument for property values that are
- * ConditionalExpression (ternary) nodes referencing the spec parameter.
- *
- * At runtime, `spec.env === 'production' ? 3 : 1` evaluates to `1` because
- * `===` on proxies returns false. But in the serialized Kro YAML, this should
- * be a CEL conditional: `${schema.spec.env == "production" ? 3 : 1}`.
- *
- * Detected ternaries are stored as templateOverrides in the analysis result.
- */
-export declare function analyzeFactoryArgTernaries(call: CallExpression, resourceId: string, fullSource: string, specParamName: string, result: ASTAnalysisResult, optionalFieldNames?: Set<string>, lexicalAliases?: LexicalAliasScope): void;
-/**
- * Analyze a ReturnStatement's object literal for ternary expressions
- * referencing the spec parameter. These become status overrides.
- */
-export declare function analyzeReturnStatementTernaries(returnNode: ASTNode, fullSource: string, specParamName: string, result: ASTAnalysisResult, optionalFieldNames?: Set<string>, lexicalAliases?: LexicalAliasScope): void;
-/**
- * Check if a CallExpression is a `.map()` call on a spec array whose callback
- * contains factory calls. If so, return the resource ID from the factory.
- *
- * Matches: spec.workers.map(worker => Deployment({...}))
- * Also matches transpiled inline forms (no variable assignment).
- */
-export declare function findFactoryMapCall(node: ASTNode, specParamName: string): string | undefined;
-/**
- * Convert a callback expression to a CEL lambda body.
- *
- * Given: `(w) => w.status.readyReplicas > 0`
- * Extracts the body source and replaces `w.status.X` with the CEL form.
- * The callback parameter becomes the CEL lambda variable.
- */
-export declare function callbackToCelLambda(callbackNode: ASTNode, fullSource: string, _resourceId: string): {
-    lambdaVar: string;
-    body: string;
-} | undefined;
-/**
- * Analyze the return statement for collection aggregate expressions.
- *
- * Detects patterns like (with or without intermediate variables):
- *   spec.workers.map(cb).length → size(workerDep)
- *   spec.workers.map(cb).every((w) => ...) → workerDep.all(w, ...)
- *   spec.workers.map(cb).some((w) => ...) → workerDep.exists(w, ...)
- *   spec.workers.map(cb).filter((w) => ...).length → size(workerDep.filter(w, ...))
- *   spec.workers.map(cb).map((w) => ...).join(sep) → workerDep.map(w, ...).join(sep)
- *
- * Also handles transpiled forms where variable assignments are inlined.
- */
-export declare function analyzeReturnCollectionAggregates(returnNode: ASTNode, fullSource: string, _collections: Map<string, CollectionVariable>, specParamName: string, result: ASTAnalysisResult): void;
-/**
- * Try to convert an expression node containing collection aggregate patterns to CEL.
- *
- * Detects patterns like `spec.workers.map(factoryCb).length` and converts to
- * `size(workerDep)`. Works directly on the expression tree without requiring
- * variable tracking (handles transpiler inlining).
- *
- * Returns the CEL expression string (wrapped in ${}) or undefined.
- */
-export declare function convertCollectionExpressionToCel(node: ASTNode, fullSource: string, specParamName: string, collections?: Map<string, CollectionVariable>): string | undefined;
-/**
- * Convert a call expression on a factory-producing collection to CEL (unwrapped).
- *
- * Walks up the chain to find the originating `spec.arr.map(factoryCb)` call,
- * extracts the resource ID, then converts the aggregate method to CEL.
- *
- * Returns the CEL expression WITHOUT ${} wrapper, or undefined.
- */
-export declare function convertCollectionCallToCel(call: CallExpression, fullSource: string, specParamName: string, collections?: Map<string, CollectionVariable>): string | undefined;
-//# sourceMappingURL=composition-analyzer-ternary.d.ts.map

package/dist/core/expressions/composition/composition-analyzer-ternary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composition-analyzer-ternary.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/composition/composition-analyzer-ternary.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAWtE,OAAO,KAAK,EACV,iBAAiB,EACjB,OAAO,EACP,cAAc,EACd,kBAAkB,EAOnB,MAAM,iCAAiC,CAAC;AAQzC;;;;;;;;;GASG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,cAAc,EACpB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,iBAAiB,EACzB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,cAAc,CAAC,EAAE,iBAAiB,GACjC,IAAI,CAcN;AA2YD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,OAAO,EACnB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,iBAAiB,EACzB,kBAAkB,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,EAChC,cAAc,CAAC,EAAE,iBAAiB,GACjC,IAAI,CA+CN;AAMD;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS,CAoB3F;AAED;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CACjC,YAAY,EAAE,OAAO,EACrB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,GAClB;IAAE,SAAS,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,GAAG,SAAS,CAkCjD;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iCAAiC,CAC/C,UAAU,EAAE,OAAO,EACnB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7C,aAAa,EAAE,MAAM,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CAgCN;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAC5C,MAAM,GAAG,SAAS,CA8CpB;AAED;;;;;;;GAOG;AACH,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,cAAc,EACpB,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,WAAW,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,GAC5C,MAAM,GAAG,SAAS,CAsFpB"}

package/dist/core/expressions/composition/composition-analyzer-traversal.d.ts

@@ -1,37 +0,0 @@
-/**
- * Core recursive AST traversal for the composition body analyzer.
- *
- * Contains the mutually recursive `walkBody`, `walkStatement`, and `walkExpression`
- * functions, plus the `registerResourceControlFlow` and `extractFunctionBody` helpers.
- *
- * These functions MUST stay together because they are mutually recursive.
- */
-import type { ASTAnalysisResult, ASTNode, TraversalContext } from './composition-analyzer-types.js';
-/**
- * Walk the AST body to find factory calls and their enclosing control flow.
- *
- * This uses a recursive visitor that tracks the current stack of control flow
- * constructs (ForOfStatement, IfStatement) and attaches them when a factory
- * call is found.
- */
-export declare function walkBody(body: ASTNode[], fullSource: string, specParamName: string, ctx: TraversalContext, result: ASTAnalysisResult): void;
-export declare function walkStatement(node: ASTNode, fullSource: string, specParamName: string, ctx: TraversalContext, result: ASTAnalysisResult): void;
-/**
- * Walk an expression node looking for factory calls and control flow patterns.
- */
-export declare function walkExpression(node: ASTNode, fullSource: string, specParamName: string, ctx: TraversalContext, result: ASTAnalysisResult): void;
-/**
- * Register the control flow context for a resource.
- *
- * If the resource was already seen, this merges the contexts (this handles
- * cases where a factory call appears in multiple code paths, though this
- * is unlikely for well-formed compositions).
- */
-export declare function registerResourceControlFlow(resourceId: string, factoryName: string, ctx: TraversalContext, result: ASTAnalysisResult): void;
-/**
- * Extract the body statements from the parsed function AST.
- */
-export declare function extractFunctionBody(ast: ASTNode & {
-    body: ASTNode[];
-}): ASTNode[] | null;
-//# sourceMappingURL=composition-analyzer-traversal.d.ts.map

package/dist/core/expressions/composition/composition-analyzer-traversal.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"composition-analyzer-traversal.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/composition/composition-analyzer-traversal.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAqBH,OAAO,KAAK,EACV,iBAAiB,EACjB,OAAO,EAUP,gBAAgB,EAEjB,MAAM,iCAAiC,CAAC;AAgCzC;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,OAAO,EAAE,EACf,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CAIN;AAED,wBAAgB,aAAa,CAC3B,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CAuON;AAED;;GAEG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,OAAO,EACb,UAAU,EAAE,MAAM,EAClB,aAAa,EAAE,MAAM,EACrB,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CA2RN;AAMD;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,gBAAgB,EACrB,MAAM,EAAE,iBAAiB,GACxB,IAAI,CA8BN;AAMD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,OAAO,GAAG;IAAE,IAAI,EAAE,OAAO,EAAE,CAAA;CAAE,GAAG,OAAO,EAAE,GAAG,IAAI,CAyBxF"}

package/dist/core/expressions/composition/context-tracker.d.ts

@@ -1,39 +0,0 @@
-/**
- * Context-Aware Resource Tracking for Composition Integration
- *
- * Tracks KubernetesRef usage across composition contexts, providing caching
- * and cross-resource reference analysis.
- */
-import type { CompositionContext } from '../../composition/context.js';
-import type { KubernetesRef } from '../../types/common.js';
-import type { Enhanced } from '../../types.js';
-/**
- * Context-aware resource tracking for composition integration
- */
-export declare class CompositionContextTracker {
-    private contextAnalysisCache;
-    resourceKubernetesRefCache: Map<string, KubernetesRef<unknown>[]>;
-    /**
-     * Track KubernetesRef usage in a composition context
-     */
-    trackCompositionContext(context: CompositionContext): {
-        totalKubernetesRefs: number;
-        resourcesWithKubernetesRefs: string[];
-        crossResourceReferences: Array<{
-            sourceResource: string;
-            targetResource: string;
-            fieldPath: string;
-        }>;
-    };
-    /**
-     * Get cached KubernetesRef objects for a resource
-     */
-    getCachedResourceKubernetesRefs(resourceId: string): KubernetesRef<unknown>[];
-    /**
-     * Clear caches for a specific context
-     */
-    clearContextCache(contextId: string): void;
-    /** Delegate to canonical implementation in type-guards.ts */
-    extractKubernetesRefsFromResource(resource: Enhanced<unknown, unknown>): KubernetesRef<unknown>[];
-}
-//# sourceMappingURL=context-tracker.d.ts.map

package/dist/core/expressions/composition/context-tracker.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"context-tracker.d.ts","sourceRoot":"","sources":["../../../../src/core/expressions/composition/context-tracker.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AACvE,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,uBAAuB,CAAC;AAE3D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAG/C;;GAEG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,oBAAoB,CAAmE;IACxF,0BAA0B,wCAA+C;IAEhF;;OAEG;IACH,uBAAuB,CAAC,OAAO,EAAE,kBAAkB,GAAG;QACpD,mBAAmB,EAAE,MAAM,CAAC;QAC5B,2BAA2B,EAAE,MAAM,EAAE,CAAC;QACtC,uBAAuB,EAAE,KAAK,CAAC;YAC7B,cAAc,EAAE,MAAM,CAAC;YACvB,cAAc,EAAE,MAAM,CAAC;YACvB,SAAS,EAAE,MAAM,CAAC;SACnB,CAAC,CAAC;KACJ;IAwCD;;OAEG;IACH,+BAA+B,CAAC,UAAU,EAAE,MAAM,GAAG,aAAa,CAAC,OAAO,CAAC,EAAE;IAI7E;;OAEG;IACH,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI1C,6DAA6D;IACtD,iCAAiC,CACtC,QAAQ,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GACnC,aAAa,CAAC,OAAO,CAAC,EAAE;CAG5B"}