typekro 0.4.0 → 0.5.0

package/dist/factories/pebble/resources/helm.js.map

@@ -1 +1 @@
-{"version":3,"file":"helm.js","sourceRoot":"","sources":["../../../../src/factories/pebble/resources/helm.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"helm.js","sourceRoot":"","sources":["../../../../src/factories/pebble/resources/helm.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EAAE,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAE1E,OAAO,EACL,sCAAsC,GAGvC,MAAM,+BAA+B,CAAC;AACvC,OAAO,EAAE,iCAAiC,EAAE,MAAM,oCAAoC,CAAC;AAEvF,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,gFAAgF;AAChF,iCAAiC;AACjC,gFAAgF;AAEhF,qFAAqF;AACrF,MAAM,sCAAsC,GAAG,sCAAsC,CAAC,QAAQ,CAAC,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,oBAAoB,CAClC,MAAkC;IAElC,OAAO,cAAc,CAA2C;QAC9D,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QACnC,UAAU,EAAE,6BAA6B;QACzC,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,sBAAsB;SACtD;QACD,IAAI,EAAE;YACJ,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,0CAA0C;YAC7D,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;SAClC;KACF,CAAC,CAAC,sBAAsB,CAAC,sCAAsC,CAAC,CAAC;AACpE,CAAC;AAED,gFAAgF;AAChF,8BAA8B;AAC9B,gFAAgF;AAEhF,kFAAkF;AAClF,MAAM,mCAAmC,GAAG,iCAAiC,CAAC,QAAQ,CAAC,CAAC;AAExF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsDG;AACH,MAAM,UAAU,iBAAiB,CAC/B,MAA+B;IAE/B,OAAO,cAAc,CAAqC;QACxD,GAAG,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,CAAC,EAAE,EAAE,CAAC;QACnC,UAAU,EAAE,2BAA2B;QACvC,IAAI,EAAE,aAAa;QACnB,QAAQ,EAAE;YACR,IAAI,EAAE,MAAM,CAAC,IAAI;YACjB,SAAS,EAAE,MAAM,CAAC,SAAS,IAAI,SAAS;SACzC;QACD,IAAI,EAAE;YACJ,KAAK,EAAE;gBACL,IAAI,EAAE;oBACJ,KAAK,EAAE,MAAM,CAAC,KAAK,EAAE,IAAI,IAAI,QAAQ;oBACrC,OAAO,EAAE,MAAM,CAAC,KAAK,EAAE,OAAO,IAAI,GAAG;oBACrC,SAAS,EAAE;wBACT,IAAI,EAAE,gBAAgB;wBACtB,IAAI,EAAE,MAAM,CAAC,aAAa,EAAE,IAAI,IAAI,aAAa;wBACjD,SAAS,EAAE,MAAM,CAAC,aAAa,EAAE,SAAS,IAAI,sBAAsB;qBACrE;iBACF;aACF;YACD,QAAQ,EAAE,MAAM,CAAC,QAAQ,IAAI,IAAI;YACjC,GAAG,CAAC,MAAM,CAAC,MAAM,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;SAChD;KACF,CAAC,CAAC,sBAAsB,CAAC,mCAAmC,CAAC,CAAC;AACjE,CAAC"}

package/dist/factories/shared.d.ts

@@ -1,77 +1,18 @@
 /**
  * Shared utilities for factory functions
  *
- * This module contains common utilities and helper functions that are used
- * across all factory modules for creating Kubernetes resources.
- */
-import type { V1PodSpec } from '@kubernetes/client-node';
-import type { Enhanced, KubernetesResource } from '../core/types.js';
-/**
- * Context for imperative composition pattern
- * Tracks resources and deployment closures created during composition function execution
- */
-export interface CompositionContext {
-    /** Map of resource ID to Enhanced resource */
-    resources: Record<string, Enhanced<any, any>>;
-    /** Map of closure ID to deployment closure */
-    closures: Record<string, any>;
-    /** Counter for generating unique resource IDs */
-    resourceCounter: number;
-    /** Counter for generating unique closure IDs */
-    closureCounter: number;
-    /** Counter for composition instances */
-    compositionInstanceCounter: number;
-    /** Map of variable names to resource IDs for CEL expression generation */
-    variableMappings: Record<string, string>;
-    /** Add a resource to the context */
-    addResource(id: string, resource: Enhanced<any, any>): void;
-    /** Add a deployment closure to the context */
-    addClosure(id: string, closure: any): void;
-    /** Add a variable to resource ID mapping */
-    addVariableMapping(variableName: string, resourceId: string): void;
-    /** Generate a unique resource ID */
-    generateResourceId(kind: string, name?: string): string;
-    /** Generate a unique closure ID */
-    generateClosureId(name?: string): string;
-}
-/**
- * Get the current composition context if one is active
- * @returns The active composition context or undefined if not in composition
- */
-export declare function getCurrentCompositionContext(): CompositionContext | undefined;
-/**
- * Run a function with a composition context
- * @param context The composition context to use
- * @param fn The function to run with the context
- * @returns The result of the function
- */
-export declare function runWithCompositionContext<T>(context: CompositionContext, fn: () => T): T;
-/**
- * Generic deployment closure registration wrapper
- * Automatically registers any deployment closure with the active composition context
+ * This module re-exports the core proxy engine (`createResource`) and
+ * composition context infrastructure for backward compatibility with
+ * existing factory consumers.
  *
- * @param closureFactory Function that creates the deployment closure
- * @param name Optional name for the closure (used for ID generation)
- * @returns The deployment closure, registered with context if active
- */
-export declare function registerDeploymentClosure<T>(closureFactory: () => T, name?: string): T;
-/**
- * Create a new composition context with default implementations
- * @param name Optional name for the composition (used in ID generation)
- * @returns A new composition context
- */
-export declare function createCompositionContext(name?: string): CompositionContext;
-/**
- * Options for createResource function
+ * The canonical implementations live in:
+ * - Proxy engine: `src/core/proxy/create-resource.ts`
+ * - Composition context: `src/core/composition/context.ts`
  */
-export interface CreateResourceOptions {
-    /**
-     * Kubernetes scope of the resource
-     * - 'namespaced': Resource must exist within a namespace
-     * - 'cluster': Resource is cluster-scoped and cannot have a namespace
-     */
-    scope?: 'namespaced' | 'cluster';
-}
-export declare function createResource<TSpec extends object, TStatus extends object>(resource: KubernetesResource<TSpec, TStatus>, options?: CreateResourceOptions): Enhanced<TSpec, TStatus>;
-export declare function processPodSpec(podSpec?: V1PodSpec): V1PodSpec | undefined;
+import type { CompositionContext, CompositionContextOptions } from '../core/composition/context.js';
+import { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext } from '../core/composition/context.js';
+export type { CompositionContext, CompositionContextOptions };
+export { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext, };
+export type { CreateResourceOptions } from '../core/proxy/create-resource.js';
+export { createResource } from '../core/proxy/create-resource.js';
 //# sourceMappingURL=shared.d.ts.map

package/dist/factories/shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/factories/shared.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,OAAO,KAAK,EAAY,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAInE,OAAO,KAAK,EACV,QAAQ,EACR,kBAAkB,EAGnB,MAAM,kBAAkB,CAAC;AAgB1B;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAC,CAAC;IAC9C,8CAA8C;IAC9C,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,iDAAiD;IACjD,eAAe,EAAE,MAAM,CAAC;IACxB,gDAAgD;IAChD,cAAc,EAAE,MAAM,CAAC;IACvB,wCAAwC;IACxC,0BAA0B,EAAE,MAAM,CAAC;IACnC,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,oCAAoC;IACpC,WAAW,CAAC,EAAE,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,IAAI,CAAC;IAC5D,8CAA8C;IAC9C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,EAAE,GAAG,GAAG,IAAI,CAAC;IAC3C,4CAA4C;IAC5C,kBAAkB,CAAC,YAAY,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,IAAI,CAAC;IACnE,oCAAoC;IACpC,kBAAkB,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACxD,mCAAmC;IACnC,iBAAiB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;CAC1C;AAQD;;;GAGG;AACH,wBAAgB,4BAA4B,IAAI,kBAAkB,GAAG,SAAS,CAE7E;AAED;;;;;GAKG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,OAAO,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAExF;AAED;;;;;;;GAOG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,EAAE,cAAc,EAAE,MAAM,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,CAAC,CAYtF;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,kBAAkB,CAyB1E;AA0XD;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,KAAK,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;CAClC;AAED,wBAAgB,cAAc,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,SAAS,MAAM,EACzE,QAAQ,EAAE,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,EAC5C,OAAO,CAAC,EAAE,qBAAqB,GAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CA8F1B;AAED,wBAAgB,cAAc,CAAC,OAAO,CAAC,EAAE,SAAS,GAAG,SAAS,GAAG,SAAS,CAoBzE"}
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../src/factories/shared.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,gCAAgC,CAAC;AACpG,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,EAC1B,MAAM,gCAAgC,CAAC;AAGxC,YAAY,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,CAAC;AAC9D,OAAO,EACL,wBAAwB,EACxB,4BAA4B,EAC5B,yBAAyB,EACzB,yBAAyB,EACzB,yBAAyB,GAC1B,CAAC;AAEF,YAAY,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAE9E,OAAO,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC"}

package/dist/factories/shared.js

@@ -1,537 +1,16 @@
 /**
  * Shared utilities for factory functions
  *
- * This module contains common utilities and helper functions that are used
- * across all factory modules for creating Kubernetes resources.
- */
-import { AsyncLocalStorage } from 'node:async_hooks';
-import { KUBERNETES_REF_BRAND } from '../core/constants/brands.js';
-import { getComponentLogger } from '../core/logging/index.js';
-import { ReadinessEvaluatorRegistry } from '../core/readiness/index.js';
-import { validateResourceId } from '../core/validation/cel-validator.js';
-import { generateDeterministicResourceId, isKubernetesRef } from '../utils/index';
-import { isCelExpression } from '../utils/type-guards.js';
-import { conditionalExpressionIntegrator } from '../core/expressions/conditional-integration.js';
-// Check for the debug environment variable
-const IS_DEBUG_MODE = process.env.TYPEKRO_DEBUG === 'true';
-// Logger for debug mode
-const debugLogger = getComponentLogger('factory-proxy');
-/**
- * AsyncLocalStorage for composition context
- * Enables context-aware resource registration across async boundaries
- */
-const COMPOSITION_CONTEXT = new AsyncLocalStorage();
-/**
- * Get the current composition context if one is active
- * @returns The active composition context or undefined if not in composition
- */
-export function getCurrentCompositionContext() {
-    return COMPOSITION_CONTEXT.getStore();
-}
-/**
- * Run a function with a composition context
- * @param context The composition context to use
- * @param fn The function to run with the context
- * @returns The result of the function
- */
-export function runWithCompositionContext(context, fn) {
-    return COMPOSITION_CONTEXT.run(context, fn);
-}
-/**
- * Generic deployment closure registration wrapper
- * Automatically registers any deployment closure with the active composition context
+ * This module re-exports the core proxy engine (`createResource`) and
+ * composition context infrastructure for backward compatibility with
+ * existing factory consumers.
  *
- * @param closureFactory Function that creates the deployment closure
- * @param name Optional name for the closure (used for ID generation)
- * @returns The deployment closure, registered with context if active
- */
-export function registerDeploymentClosure(closureFactory, name) {
-    const context = getCurrentCompositionContext();
-    if (context) {
-        const closure = closureFactory();
-        const closureId = context.generateClosureId(name);
-        context.addClosure(closureId, closure);
-        return closure;
-    }
-    // Outside composition context - return closure as-is
-    return closureFactory();
-}
-/**
- * Create a new composition context with default implementations
- * @param name Optional name for the composition (used in ID generation)
- * @returns A new composition context
- */
-export function createCompositionContext(name) {
-    return {
-        resources: {},
-        closures: {},
-        resourceCounter: 0,
-        closureCounter: 0,
-        compositionInstanceCounter: 0,
-        variableMappings: {},
-        addResource(id, resource) {
-            this.resources[id] = resource;
-        },
-        addClosure(id, closure) {
-            this.closures[id] = closure;
-        },
-        addVariableMapping(variableName, resourceId) {
-            this.variableMappings[variableName] = resourceId;
-        },
-        generateResourceId(kind, resourceName) {
-            return resourceName || `${kind.toLowerCase()}-${++this.resourceCounter}`;
-        },
-        generateClosureId(closureName) {
-            const prefix = name ? `${name}-` : '';
-            return closureName ? `${prefix}${closureName}` : `${prefix}closure-${++this.closureCounter}`;
-        },
-    };
-}
-// =============================================================================
-// PROXY ENGINE & BASE FACTORY
-// =============================================================================
-function createRefFactory(resourceId, basePath) {
-    const proxyTarget = () => {
-        // Empty function used as proxy target
-    };
-    Object.defineProperty(proxyTarget, KUBERNETES_REF_BRAND, { value: true });
-    Object.defineProperty(proxyTarget, 'resourceId', { value: resourceId });
-    Object.defineProperty(proxyTarget, 'fieldPath', { value: basePath });
-    // Make the proxy compatible with string, number, and boolean types
-    Object.defineProperty(proxyTarget, 'valueOf', {
-        value: () => basePath, // Return a string representation
-        enumerable: false,
-    });
-    Object.defineProperty(proxyTarget, 'toString', {
-        value: () => basePath, // Return a string representation
-        enumerable: false,
-    });
-    return new Proxy(proxyTarget, {
-        get(target, prop) {
-            // Check for our defined properties first
-            if (prop === KUBERNETES_REF_BRAND || prop === 'resourceId' || prop === 'fieldPath') {
-                return target[prop];
-            }
-            // Check for other properties that exist on the target
-            if (prop in target)
-                return target[prop];
-            // For unknown properties, create nested references
-            return createRefFactory(resourceId, `${basePath}.${String(prop)}`);
-        },
-    }); // Force TypeScript to see this as compatible with any type
-}
-function createPropertyProxy(resourceId, basePath, target) {
-    if (IS_DEBUG_MODE) {
-        debugLogger.debug('Proxy created', { resourceId, basePath });
-    }
-    return new Proxy(target, {
-        /**
-         * Trap for Object.keys, JSON.stringify, etc.
-         * This is crucial for making the proxy serializable. It ensures that
-         * when something tries to get the keys of the proxy, it gets the keys
-         * of the underlying target object.
-         */
-        ownKeys(obj) {
-            return Reflect.ownKeys(obj);
-        },
-        /**
-         * Required for Object.keys() to work correctly with ownKeys trap
-         */
-        getOwnPropertyDescriptor(obj, prop) {
-            return Reflect.getOwnPropertyDescriptor(obj, prop);
-        },
-        get: (obj, prop) => {
-            // Handle toJSON specially to ensure proper serialization
-            if (prop === 'toJSON') {
-                return () => {
-                    // Deep clone with array preservation
-                    const deepClone = (value) => {
-                        if (value === null || value === undefined)
-                            return value;
-                        if (typeof value !== 'object')
-                            return value;
-                        if (value instanceof Date)
-                            return new Date(value);
-                        if (value instanceof RegExp)
-                            return new RegExp(value);
-                        if (Array.isArray(value)) {
-                            return value.map((item) => deepClone(item));
-                        }
-                        const cloned = {};
-                        for (const k of Object.keys(value)) {
-                            if (typeof value[k] !== 'function') {
-                                cloned[k] = deepClone(value[k]);
-                            }
-                        }
-                        return cloned;
-                    };
-                    const result = {};
-                    for (const key of Object.keys(obj)) {
-                        result[key] = deepClone(obj[key]);
-                    }
-                    return result;
-                };
-            }
-            // 1. Immediately handle non-string properties.
-            if (typeof prop !== 'string') {
-                return obj[prop];
-            }
-            // 2. Check if the user is explicitly requesting a reference with the '$' prefix.
-            if (prop.startsWith('$')) {
-                const actualProp = prop.substring(1);
-                // Return the KubernetesRef for the underlying property.
-                return createRefFactory(resourceId, `${basePath}.${actualProp}`);
-            }
-            // 3. For any other access, default to the "eager value" or "implicit ref for unknown" logic.
-            // IMPORTANT: For JavaScript-to-CEL conversion to work, we need to check if we're in
-            // a status builder context where ALL property access should return KubernetesRef objects
-            const isStatusBuilderContext = globalThis.__TYPEKRO_STATUS_BUILDER_CONTEXT__;
-            if (isStatusBuilderContext && (basePath === 'status' || basePath === 'spec')) {
-                // In status builder context, ALWAYS return KubernetesRef objects for spec/status fields
-                // This allows expressions like `resources.deployment.status.readyReplicas > 0` to work
-                return createRefFactory(resourceId, `${basePath}.${String(prop)}`);
-            }
-            if (prop in obj) {
-                // If it's a known property, return its value.
-                return obj[prop];
-            }
-            else {
-                // If it's an unknown property (like from a schema), create the reference implicitly.
-                return createRefFactory(resourceId, `${basePath}.${String(prop)}`);
-            }
-        },
-        set: (obj, prop, value) => {
-            if (IS_DEBUG_MODE) {
-                debugLogger.debug('Proxy property set', { basePath, prop: String(prop), value });
-            }
-            // Transparently accept KubernetesRef and CelExpression objects
-            // The serialization system will handle converting them to CEL expressions
-            return Reflect.set(obj, prop, value);
-        },
-    });
-}
-function createGenericProxyResource(resourceId, resource) {
-    Object.defineProperty(resource, '__resourceId', {
-        value: resourceId,
-        enumerable: false,
-        configurable: true,
-    });
-    // Cache proxies to ensure the same proxy is returned each time
-    let specProxy;
-    let statusProxy;
-    return new Proxy(resource, {
-        /**
-         * Trap for Object.keys, JSON.stringify, etc.
-         * This is crucial for making the proxy serializable. It ensures that
-         * when something tries to get the keys of the proxy, it gets the keys
-         * of the underlying resource object.
-         */
-        ownKeys(target) {
-            return Reflect.ownKeys(target);
-        },
-        get(target, prop, receiver) {
-            // Handle toJSON specially to ensure proper serialization
-            if (prop === 'toJSON') {
-                return () => {
-                    // Deep clone with array preservation
-                    // Cannot use structuredClone because it can't clone functions (readinessEvaluator)
-                    const deepClone = (obj) => {
-                        if (obj === null || obj === undefined)
-                            return obj;
-                        if (typeof obj !== 'object')
-                            return obj;
-                        if (obj instanceof Date)
-                            return new Date(obj);
-                        if (obj instanceof RegExp)
-                            return new RegExp(obj);
-                        if (Array.isArray(obj)) {
-                            return obj.map((item) => deepClone(item));
-                        }
-                        const result = {};
-                        for (const key of Object.keys(obj)) {
-                            if (typeof obj[key] !== 'function') {
-                                result[key] = deepClone(obj[key]);
-                            }
-                        }
-                        return result;
-                    };
-                    // Clone and filter out internal fields that should not be sent to Kubernetes
-                    const result = {};
-                    for (const key of Object.keys(target)) {
-                        if (key !== '__resourceId' &&
-                            key !== 'withReadinessEvaluator' &&
-                            key !== 'readinessEvaluator' &&
-                            key !== 'id' // Filter out id field - it's for TypeKro internal use only
-                        ) {
-                            result[key] = deepClone(target[key]);
-                        }
-                    }
-                    return result;
-                };
-            }
-            if (prop === 'spec') {
-                if (!specProxy) {
-                    const spec = target.spec ?? {};
-                    specProxy = createPropertyProxy(resourceId, 'spec', spec);
-                }
-                return specProxy;
-            }
-            if (prop === 'status') {
-                if (!statusProxy) {
-                    const status = target.status ?? {};
-                    statusProxy = createPropertyProxy(resourceId, 'status', status);
-                }
-                return statusProxy;
-            }
-            if (prop === 'metadata') {
-                // For metadata, we need to ensure it's serializable while still providing proxy functionality
-                const metadata = target.metadata || {};
-                const metadataProxy = createPropertyProxy(resourceId, 'metadata', metadata);
-                // Add enumerable properties to make it JSON serializable
-                // This ensures that JSON.stringify can access the metadata fields
-                if (metadata && typeof metadata === 'object') {
-                    for (const [key, value] of Object.entries(metadata)) {
-                        if (!Object.hasOwn(metadataProxy, key)) {
-                            Object.defineProperty(metadataProxy, key, {
-                                value: value,
-                                enumerable: true,
-                                configurable: true,
-                                writable: true,
-                            });
-                        }
-                    }
-                }
-                return metadataProxy;
-            }
-            if (prop === 'id') {
-                return resourceId; // Return the resource ID directly
-            }
-            // Handle common Kubernetes resource fields as magic proxies
-            if (prop === 'data' && 'data' in target) {
-                const data = target.data ?? {};
-                return createPropertyProxy(resourceId, 'data', data);
-            }
-            if (prop === 'stringData' && 'stringData' in target) {
-                const stringData = target.stringData ?? {};
-                return createPropertyProxy(resourceId, 'stringData', stringData);
-            }
-            if (prop === 'rules' && 'rules' in target) {
-                const rules = target.rules ?? [];
-                return createPropertyProxy(resourceId, 'rules', rules);
-            }
-            if (prop === 'roleRef' && 'roleRef' in target) {
-                const roleRef = target.roleRef ?? {};
-                return createPropertyProxy(resourceId, 'roleRef', roleRef);
-            }
-            if (prop === 'subjects' && 'subjects' in target) {
-                const subjects = target.subjects ?? [];
-                return createPropertyProxy(resourceId, 'subjects', subjects);
-            }
-            if (prop === 'provisioner' && 'provisioner' in target) {
-                const provisioner = target.provisioner;
-                if (provisioner !== undefined) {
-                    return provisioner; // Return the actual string value
-                }
-                return createRefFactory(resourceId, 'provisioner'); // Create reference if not set
-            }
-            if (prop === 'parameters' && 'parameters' in target) {
-                const parameters = target.parameters ?? {};
-                return createPropertyProxy(resourceId, 'parameters', parameters);
-            }
-            if (prop === 'subsets' && 'subsets' in target) {
-                const subsets = target.subsets ?? [];
-                return createPropertyProxy(resourceId, 'subsets', subsets);
-            }
-            if (typeof prop === 'string' && prop.startsWith('$')) {
-                return createRefFactory(resourceId, prop.substring(1));
-            }
-            return Reflect.get(target, prop, receiver);
-        },
-        set(target, prop, value, receiver) {
-            // Transparently accept KubernetesRef and CelExpression objects
-            // The serialization system will handle converting them to CEL expressions
-            return Reflect.set(target, prop, value, receiver);
-        },
-    });
-}
-/**
- * Default readiness evaluator for resources that don't have custom logic
+ * The canonical implementations live in:
+ * - Proxy engine: `src/core/proxy/create-resource.ts`
+ * - Composition context: `src/core/composition/context.ts`
  */
-function createDefaultReadinessEvaluator(kind) {
-    return (liveResource) => {
-        try {
-            // For resources that are immediately ready when they exist
-            const immediatelyReadyKinds = [
-                'ConfigMap',
-                'Secret',
-                'Role',
-                'ClusterRole',
-                'RoleBinding',
-                'ClusterRoleBinding',
-                'ServiceAccount',
-                'StorageClass',
-                'NetworkPolicy',
-                'LimitRange',
-                'CSIDriver',
-                'CSINode',
-                'IngressClass',
-                'RuntimeClass',
-                'Lease',
-                'ComponentStatus',
-            ];
-            if (immediatelyReadyKinds.includes(kind)) {
-                return {
-                    ready: true,
-                    message: `${kind} is ready when it exists`,
-                };
-            }
-            // For resources with status conditions, check for common readiness patterns
-            const status = liveResource.status;
-            if (!status) {
-                return {
-                    ready: false,
-                    reason: 'StatusMissing',
-                    message: `${kind} status not available yet`,
-                };
-            }
-            // Check for common readiness conditions
-            if (status.conditions && Array.isArray(status.conditions)) {
-                const readyCondition = status.conditions.find((c) => c.type === 'Ready');
-                if (readyCondition) {
-                    return {
-                        ready: readyCondition.status === 'True',
-                        reason: readyCondition.reason,
-                        message: readyCondition.message || `${kind} readiness: ${readyCondition.status}`,
-                    };
-                }
-                const availableCondition = status.conditions.find((c) => c.type === 'Available');
-                if (availableCondition) {
-                    return {
-                        ready: availableCondition.status === 'True',
-                        reason: availableCondition.reason,
-                        message: availableCondition.message || `${kind} availability: ${availableCondition.status}`,
-                    };
-                }
-            }
-            // For resources with phase, check if it's active/bound/running
-            if (status.phase) {
-                const readyPhases = ['Active', 'Bound', 'Running', 'Succeeded'];
-                const ready = readyPhases.includes(status.phase);
-                return {
-                    ready,
-                    reason: ready ? 'PhaseReady' : 'PhaseNotReady',
-                    message: `${kind} phase: ${status.phase}`,
-                };
-            }
-            // Default: assume ready if status exists
-            return {
-                ready: true,
-                message: `${kind} has status, assuming ready`,
-            };
-        }
-        catch (error) {
-            return {
-                ready: false,
-                reason: 'EvaluationError',
-                message: `Error evaluating ${kind} readiness: ${error}`,
-            };
-        }
-    };
-}
-export function createResource(resource, options) {
-    // Validate namespace scope rules
-    if (options?.scope) {
-        const hasNamespace = !!resource.metadata?.namespace;
-        if (options.scope === 'cluster' && hasNamespace) {
-            throw new Error(`${resource.kind} is cluster-scoped and cannot have a namespace. ` +
-                `Remove the 'namespace' field from metadata.`);
-        }
-        if (options.scope === 'namespaced' && !hasNamespace) {
-            debugLogger.warn(`${resource.kind} is namespaced but no namespace specified. Kubernetes will use 'default'.`, {
-                kind: resource.kind,
-                name: resource.metadata?.name,
-            });
-        }
-    }
-    let resourceId;
-    // Check for id field on the resource itself
-    if (resource.id) {
-        resourceId = resource.id;
-        // Validate that the ID follows camelCase convention
-        const validation = validateResourceId(resourceId);
-        if (!validation.isValid) {
-            throw new Error(`Invalid resource ID: ${validation.error}`);
-        }
-        // Remove the id field from the resource to prevent it from being sent to Kubernetes
-        const { id: _id, ...cleanResource } = resource;
-        resource = cleanResource;
-    }
-    else {
-        // Use deterministic ID generation by default
-        const name = resource.metadata?.name || resource.kind.toLowerCase();
-        const namespace = resource.metadata?.namespace;
-        resourceId = generateDeterministicResourceId(resource.kind, name, namespace);
-    }
-    const enhanced = createGenericProxyResource(resourceId, resource);
-    // Auto-register with composition context if active (but not for external references)
-    const context = getCurrentCompositionContext();
-    if (context && !resource.__externalRef) {
-        context.addResource(resourceId, enhanced);
-    }
-    // Always provide a readiness evaluator for factory-created resources
-    const defaultEvaluator = createDefaultReadinessEvaluator(resource.kind);
-    Object.defineProperty(enhanced, 'readinessEvaluator', {
-        value: defaultEvaluator,
-        enumerable: false, // Prevents serialization - key requirement
-        configurable: true, // Allow withReadinessEvaluator to override
-        writable: false, // Cannot be overwritten directly
-    });
-    // Add fluent builder method for readiness evaluator with serialization protection
-    Object.defineProperty(enhanced, 'withReadinessEvaluator', {
-        value: function (evaluator) {
-            // Register in global registry by KIND when factory defines evaluator
-            ReadinessEvaluatorRegistry.getInstance().registerForKind(this.kind, evaluator, 'factory-defined');
-            // Still attach to individual resource instance (existing behavior)
-            Object.defineProperty(this, 'readinessEvaluator', {
-                value: evaluator,
-                enumerable: false, // Prevents serialization - key requirement
-                configurable: true, // Allow reconfiguration for withReadinessEvaluator
-                writable: false, // Cannot be overwritten directly
-            });
-            return this;
-        },
-        enumerable: false, // Prevents withReadinessEvaluator from being serialized
-        configurable: false, // Cannot be modified
-        writable: false, // Cannot be overwritten
-    });
-    // Add conditional expression support
-    const enhancedWithConditionals = conditionalExpressionIntegrator.addConditionalSupport(enhanced, {
-        autoProcess: false, // Don't auto-process until we know the factory type
-        validateExpressions: true,
-    });
-    return enhancedWithConditionals;
-}
-export function processPodSpec(podSpec) {
-    if (!podSpec?.containers)
-        return podSpec;
-    podSpec.containers = podSpec.containers.map((container) => {
-        if (!container.env)
-            return container;
-        const processedEnv = container.env.map((envVar) => {
-            if (isKubernetesRef(envVar.value)) {
-                return { name: envVar.name, value: envVar.value };
-            }
-            // Check if it's a CelExpression - preserve it as-is
-            if (isCelExpression(envVar.value)) {
-                return { name: envVar.name, value: envVar.value };
-            }
-            if (envVar.value !== undefined) {
-                return { name: envVar.name, value: String(envVar.value) };
-            }
-            return envVar;
-        });
-        return { ...container, env: processedEnv };
-    });
-    return podSpec;
-}
+import { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext, } from '../core/composition/context.js';
+export { createCompositionContext, getCurrentCompositionContext, registerDeploymentClosure, runInStatusBuilderContext, runWithCompositionContext, };
+// Re-export proxy engine from its canonical location in core/
+export { createResource } from '../core/proxy/create-resource.js';
 //# sourceMappingURL=shared.js.map