typekro 0.14.0 → 0.15.1

package/dist/core/deployment/kro-factory.d.ts

@@ -4,6 +4,7 @@
  * This factory handles deployment via Kro ResourceGraphDefinitions,
  * using the Kro controller for dependency resolution and resource management.
  */
+import type { AlchemyResourceDeclaration } from '../../alchemy/types.js';
 import type { FactoryOptions, FactoryStatus, KroResourceFactory, RGDStatus } from '../types/deployment.js';
 import type { Enhanced, KubernetesResource } from '../types/kubernetes.js';
 import type { KroCompatibleType, MagicAssignableShape, SchemaDefinition, SchemaProxy } from '../types/serialization.js';
@@ -48,14 +49,12 @@ export declare class KroResourceFactoryImpl<TSpec extends KroCompatibleType, TSt
     readonly mode: "kro";
     readonly name: string;
     readonly namespace: string;
-    readonly isAlchemyManaged: boolean;
     readonly rgdName: string;
     readonly schema: SchemaProxy<TSpec, TStatus>;
     private readonly resources;
     private readonly closures;
     private readonly schemaDefinition;
     private readonly statusMappings;
-    private readonly alchemyScope;
     private readonly singletonDefinitions;
     private readonly singletonOwnerStatuses;
     private readonly logger;
@@ -84,7 +83,6 @@ export declare class KroResourceFactoryImpl<TSpec extends KroCompatibleType, TSt
     private discoveredPlural;
     private readonly kroCustomResourceProvider;
     private readonly rgdProvider;
-    private readonly alchemyBridge;
     constructor(name: string, resources: Record<string, KubernetesResource>, schemaDefinition: SchemaDefinition<TSpec, TStatus>, statusMappings: MagicAssignableShape<TStatus>, options?: FactoryOptions);
     /** Extract nested composition status CEL mappings from the raw status object. */
     private getNestedStatusCel;
@@ -142,6 +140,14 @@ export declare class KroResourceFactoryImpl<TSpec extends KroCompatibleType, TSt
         instanceNameOverride?: string;
         singletonSpecFingerprint?: string;
     }): Promise<Enhanced<TSpec, TStatus>>;
+    /**
+     * Discover the singleton-owner definitions this composition depends on (deduped by key): from
+     * re-executing the composition fn under a discovery context, plus any injected definitions.
+     * Shared by {@link ensureSingletonOwners} (imperative deploy) and {@link toAlchemyResources}.
+     */
+    private discoverSingletonDefinitions;
+    /** Build the KRO factory that owns a singleton's RGD + instance (its registry namespace). */
+    private singletonFactoryFor;
     private ensureSingletonOwners;
     private getSingletonOwnerInstancesForDriftCheck;
     private isMissingSingletonOwnerCrdError;
@@ -154,12 +160,6 @@ export declare class KroResourceFactoryImpl<TSpec extends KroCompatibleType, TSt
      * Deploy directly to Kubernetes using DirectDeploymentEngine
      */
     private deployDirect;
-    /**
-     * Deploy using type-safe alchemy resource wrapping
-     *
-     * In alchemy mode, the RGD gets one typed alchemy Resource and each instance gets another
-     */
-    private deployWithAlchemy;
     /**
      * Get all deployed instances
      */
@@ -173,7 +173,33 @@ export declare class KroResourceFactoryImpl<TSpec extends KroCompatibleType, TSt
         scopes?: string[];
         includeUnscopedResources?: boolean;
     }): Promise<void>;
+    /**
+     * Emit this factory's KRO deployment as declarative alchemy **v2** resources — the v2
+     * analog of the removed imperative `deployWithAlchemy(scope)`. Returns, in dependency order, a
+     * declaration for each discovered **singleton owner** (its own RGD + instance — mirroring
+     * `ensureSingletonOwners` in the imperative `deploy()` path), then the **RGD** (shared, deployed
+     * once), then the **CR instance** (one per `spec`, which `dependsOn` the RGD + the singletons),
+     * matching the old integration's per-resource state granularity. The caller instantiates
+     * each with `KroResource` inside their Stack (RGD first so reverse-topo removes the
+     * instance before the shared RGD):
+     *
+     * ```ts
+     * for (const { id, props } of await factory.toAlchemyResources(spec)) {
+     *   yield* KroResource(id, props);
+     * }
+     * ```
+     *
+     * Each declaration carries serialized `kubeConfigOptions` (so reconcile can reconnect to the
+     * cluster after state rehydration) and `kroDeletion` (so delete is finalizer-safe / shared-RGD
+     * aware). The actual deploy/teardown runs in `kroProvider`'s reconcile/delete.
+     */
+    toAlchemyResources(spec: TSpec, opts?: {
+        instanceNameOverride?: string;
+        singletonSpecFingerprint?: string;
+    }): Promise<AlchemyResourceDeclaration[]>;
+    /** Serialize the factory's cluster connection so an alchemy resource can reconnect after rehydration. */
     private extractKubeConfigOptionsForAlchemy;
+    /** Build the finalizer-safe, shared-RGD-aware deletion metadata for this factory's instances. */
     private createAlchemyKroDeletionOptions;
     /**
      * Get factory status

package/dist/core/deployment/kro-factory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kro-factory.d.ts","sourceRoot":"","sources":["../../../src/core/deployment/kro-factory.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAqCH,OAAO,KAAK,EAKV,cAAc,EACd,aAAa,EAGb,kBAAkB,EAElB,SAAS,EAEV,MAAM,wBAAwB,CAAC;AAChC,OAAO,KAAK,EAAyB,QAAQ,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAClG,OAAO,KAAK,EACV,iBAAiB,EACjB,oBAAoB,EACpB,gBAAgB,EAChB,WAAW,EAEZ,MAAM,2BAA2B,CAAC;AAwBnC;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,wBAAgB,iBAAiB,CAI/B,SAAS,EAAE,aAAa,CAAC;IAAE,QAAQ,CAAC,EAAE;QAAE,IAAI,CAAC,EAAE,OAAO,CAAC;QAAC,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,CAAA;CAAE,CAAC,EAChF,UAAU,EAAE,MAAM,EAClB,eAAe,EAAE,OAAO,EACxB,eAAe,CAAC,EAAE,MAAM,GACvB,OAAO,CAST;AA8BD;;;;;GAKG;AACH,qBAAa,sBAAsB,CACjC,KAAK,SAAS,iBAAiB,EAC/B,OAAO,SAAS,iBAAiB,CACjC,YAAW,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC;IAE7C,QAAQ,CAAC,IAAI,EAAG,KAAK,CAAU;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,gBAAgB,EAAE,OAAO,CAAC;IACnC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;IAE7C,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAqC;IAC/D,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAoC;IAC7D,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAmC;IACpE,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA0B;IACzD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAoB;IACjD,OAAO,CAAC,QAAQ,CAAC,oBAAoB,CAA8B;IACnE,OAAO,CAAC,QAAQ,CAAC,sBAAsB,CAA8C;IACrF,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAqC;IAC5D,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAiB;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA0B;IACxD;;;;;;OAMG;IACH,OAAO,CAAC,qBAAqB,CAAS;IACtC,OAAO,CAAC,0BAA0B,CAAS;IAE3C;;;;;;;;;;OAUG;IACH,OAAO,CAAC,gBAAgB,CAAqB;IAI7C,OAAO,CAAC,QAAQ,CAAC,yBAAyB,CAAwC;IAClF,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8C;IAC1E,OAAO,CAAC,QAAQ,CAAC,aAAa,CAA4B;gBAGxD,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7C,gBAAgB,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,EAClD,cAAc,EAAE,oBAAoB,CAAC,OAAO,CAAC,EAC7C,OAAO,GAAE,cAAmB;IAgC9B,iFAAiF;IACjF,OAAO,CAAC,kBAAkB;IAM1B,OAAO,CAAC,gBAAgB;IAMxB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,qBAAqB;IAI7B;;;;;;;;;OASG;YACW,qBAAqB;IAsGnC;;;;;;;;;OASG;YACW,eAAe;YA2Bf,0BAA0B;IAgBxC,OAAO,CAAC,yBAAyB;IAIjC;;;OAGG;IACH,OAAO,CAAC,0BAA0B;IAclC;;OAEG;IACH,OAAO,CAAC,iBAAiB;IAIzB;;OAEG;IACH,OAAO,CAAC,aAAa;IAIrB;;OAEG;IACH,OAAO,CAAC,mBAAmB;IAI3B,OAAO,CAAC,aAAa;IAUf,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAU9B;;OAEG;IACG,MAAM,CACV,IAAI,EAAE,KAAK,EACX,IAAI,CAAC,EAAE;QACL,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;QACxB,oBAAoB,CAAC,EAAE,MAAM,CAAC;QAC9B,wBAAwB,CAAC,EAAE,MAAM,CAAC;KACnC,GACA,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC;YA6BtB,qBAAqB;YAuFrB,uCAAuC;IAuBrD,OAAO,CAAC,+BAA+B;IAcvC;;;OAGG;YACW,wBAAwB;IAoHtC;;OAEG;YACW,YAAY;IA4F1B;;;;OAIG;YACW,iBAAiB;IAgG/B;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,EAAE,CAAC;YA0F3C,uBAAuB;YA6BvB,sBAAsB;IAOpC;;OAEG;IACG,cAAc,CAClB,IAAI,EAAE,MAAM,EACZ,IAAI,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAAC,wBAAwB,CAAC,EAAE,OAAO,CAAA;KAAE,GAC/D,OAAO,CAAC,IAAI,CAAC;IAwLhB,OAAO,CAAC,kCAAkC;IAsC1C,OAAO,CAAC,+BAA+B;IAYvC;;OAEG;IACG,SAAS,IAAI,OAAO,CAAC,aAAa,CAAC;IAczC;;OAEG;IACG,YAAY,IAAI,OAAO,CAAC,SAAS,CAAC;IA0ExC;;OAEG;IACH,MAAM,IAAI,MAAM;IAChB;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,KAAK,GAAG,MAAM;IA+B3B;;;;;;;;;;;OAWG;IACH,OAAO,CAAC,YAAY;IAgEpB,OAAO,CAAC,MAAM,CAAC,QAAQ;IAOvB,OAAO,CAAC,MAAM,CAAC,qBAAqB;IASpC;;;;OAIG;YACW,8BAA8B;IA8C5C;;OAEG;YACW,iBAAiB;IAuG/B;;;;;;;OAOG;YACW,yBAAyB;IAiBvC;;OAEG;YACW,oBAAoB;IAalC;;OAEG;YACW,oBAAoB;YAapB,wBAAwB;IAqEtC,OAAO,CAAC,qBAAqB;IAe7B;;;;;;OAMG;IACH,OAAO,CAAC,2BAA2B;IA4BnC;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IAyB/B;;;;;;OAMG;IACH,OAAO,CAAC,uBAAuB;IA4B/B;;;OAGG;IACH,OAAO,CAAC,oCAAoC;IAyB5C,OAAO,CAAC,2BAA2B;IAenC,OAAO,CAAC,cAAc;IAiBtB;;OAEG;IACH,OAAO,CAAC,eAAe;IAYvB;;OAEG;IACH,OAAO,CAAC,4BAA4B;IA8BpC;;OAEG;YACW,qCAAqC;IAsGnD;;;OAGG;YACW,uBAAuB;IA4GrC,OAAO,CAAC,gCAAgC;IAwCxC;;OAEG;YACW,mBAAmB;IAOjC;;;OAGG;YACW,uBAAuB;IAmBrC;;OAEG;YACW,0BAA0B;CA0CzC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,SAAS,iBAAiB,EAC/B,OAAO,SAAS,iBAAiB,EAEjC,IAAI,EAAE,MAAM,EACZ,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,kBAAkB,CAAC,EAC7C,gBAAgB,EAAE,gBAAgB,CAAC,KAAK,EAAE,OAAO,CAAC,EAClD,cAAc,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACvC,OAAO,GAAE,cAAmB,GAC3B,kBAAkB,CAAC,KAAK,EAAE,OAAO,CAAC,CAQpC"}
+{"version":3,"file":"kro-factory.d.ts","sourceRoot":"","sources":["../../../src/core/deployment/kro-factory.ts"],"names":[],"mappings":"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"}

package/dist/core/deployment/kro-factory.js

@@ -18,11 +18,13 @@ import { CRDInstanceError, ensureError, ResourceGraphFactoryError, TypeKroError,
 import { applyAnalysisToResources } from '../expressions/composition/composition-analyzer.js';
 import { createBunCompatibleKubernetesObjectApi } from '../kubernetes/index.js';
 import { getComponentLogger } from '../logging/index.js';
+import { createAlchemyResourceId } from '../../alchemy/utilities.js';
 // Dependency inversion: kroCustomResource, resourceGraphDefinition, and
 // alchemy bridge are injected via FactoryOptions providers (Phase 3.5)
 // instead of dynamic import() from higher layers.
 import { getMetadataField, setMetadataField } from '../metadata/index.js';
 import { createSchemaProxy, DeploymentMode } from '../references/index.js';
+import { isStaticExpression } from '../serialization/cel-references.js';
 import { applyTernaryConditionalsToResources } from '../serialization/kro-post-processing.js';
 import { generateKroSchemaFromArktype } from '../serialization/schema.js';
 import { serializeResourceGraphToYaml } from '../serialization/yaml.js';
@@ -32,7 +34,7 @@ import { DirectDeploymentEngine } from './engine.js';
 import { logHandleSnapshot } from './handle-tracing.js';
 import { isNotFoundError } from './k8s-helpers.js';
 import { waitForKroInstanceReady as waitForKroInstanceReadyShared } from './kro-readiness.js';
-import { convertToKubernetesName, generateInstanceName, getSingletonInstanceName, pluralizeKind, validateAlchemyScope, validateSpec, } from './shared-utilities.js';
+import { convertToKubernetesName, extractSerializableKubeConfigOptions, generateInstanceName, getSingletonInstanceName, pluralizeKind, validateSpec, } from './shared-utilities.js';
 import { joinYamlDocuments, singletonOwnerInstanceYamls, singletonRgdYamls, } from './singleton-gitops.js';
 import { assertNoDeployedSingletonSpecDrift, singletonSpecFingerprintAnnotationValue, } from './singleton-owner-drift.js';
 /**
@@ -104,14 +106,12 @@ export class KroResourceFactoryImpl {
     mode = 'kro';
     name;
     namespace;
-    isAlchemyManaged;
     rgdName;
     schema;
     resources;
     closures;
     schemaDefinition;
     statusMappings;
-    alchemyScope;
     singletonDefinitions;
     singletonOwnerStatuses = new Map();
     logger = getComponentLogger('kro-factory');
@@ -142,12 +142,9 @@ export class KroResourceFactoryImpl {
     // instead of dynamic import() from factories/ and alchemy/ layers.
     kroCustomResourceProvider;
     rgdProvider;
-    alchemyBridge;
     constructor(name, resources, schemaDefinition, statusMappings, options = {}) {
         this.name = name;
         this.namespace = options.namespace || 'default';
-        this.alchemyScope = options.alchemyScope;
-        this.isAlchemyManaged = !!options.alchemyScope;
         this.rgdName = convertToKubernetesName(name); // Convert to valid Kubernetes resource name
         this.resources = resources;
         this.closures = options.closures || {};
@@ -164,7 +161,6 @@ export class KroResourceFactoryImpl {
         // Injected providers — fall back to dynamic import() for backward compatibility
         this.kroCustomResourceProvider = options.kroCustomResourceProvider;
         this.rgdProvider = options.rgdProvider;
-        this.alchemyBridge = options.alchemyBridge;
         // Validate closures for Kro mode - detect KubernetesRef inputs and raise clear errors
         this.validateClosuresForKroMode();
     }
@@ -397,53 +393,49 @@ export class KroResourceFactoryImpl {
         // Execute closures before RGD creation (Kro mode requirement)
         await this.executeClosuresBeforeRGD(spec);
         await this.ensureSingletonOwners(spec);
-        if (this.isAlchemyManaged) {
-            return this.deployWithAlchemy(spec, opts?.instanceNameOverride, opts?.singletonSpecFingerprint);
-        }
-        else {
-            return this.deployDirect(spec, opts?.instanceNameOverride, opts?.singletonSpecFingerprint);
-        }
+        return this.deployDirect(spec, opts?.instanceNameOverride, opts?.singletonSpecFingerprint);
     }
-    async ensureSingletonOwners(spec) {
-        const discoveredSingletons = new Map();
+    /**
+     * Discover the singleton-owner definitions this composition depends on (deduped by key): from
+     * re-executing the composition fn under a discovery context, plus any injected definitions.
+     * Shared by {@link ensureSingletonOwners} (imperative deploy) and {@link toAlchemyResources}.
+     */
+    discoverSingletonDefinitions(spec) {
+        const discovered = new Map();
         if (this.factoryOptions.compositionFn) {
-            const singletonContext = createCompositionContext('singleton-owner-discovery');
-            runWithCompositionContext(singletonContext, () => {
+            const ctx = createCompositionContext('singleton-owner-discovery');
+            runWithCompositionContext(ctx, () => {
                 this.factoryOptions.compositionFn?.(spec);
             });
-            for (const [key, definition] of singletonContext.singletonDefinitions ?? []) {
-                discoveredSingletons.set(key, definition);
+            for (const [key, definition] of ctx.singletonDefinitions ?? []) {
+                discovered.set(key, definition);
             }
         }
         for (const definition of this.singletonDefinitions) {
-            if (!discoveredSingletons.has(definition.key)) {
-                discoveredSingletons.set(definition.key, definition);
-            }
+            if (!discovered.has(definition.key))
+                discovered.set(definition.key, definition);
         }
-        if (discoveredSingletons.size === 0)
-            return;
-        const singletonRecords = new Map();
-        for (const definition of discoveredSingletons.values()) {
-            if (!singletonRecords.has(definition.key)) {
-                singletonRecords.set(definition.key, definition);
-            }
-        }
-        for (const definition of singletonRecords.values()) {
+        return Array.from(discovered.values());
+    }
+    /** Build the KRO factory that owns a singleton's RGD + instance (its registry namespace). */
+    singletonFactoryFor(definition) {
+        return definition.composition.factory('kro', {
+            namespace: definition.registryNamespace,
+            waitForReady: true,
+            ...(this.factoryOptions.timeout !== undefined ? { timeout: this.factoryOptions.timeout } : {}),
+            ...(this.factoryOptions.kubeConfig !== undefined
+                ? { kubeConfig: this.factoryOptions.kubeConfig }
+                : {}),
+            ...(this.factoryOptions.skipTLSVerify !== undefined
+                ? { skipTLSVerify: this.factoryOptions.skipTLSVerify }
+                : {}),
+        });
+    }
+    async ensureSingletonOwners(spec) {
+        for (const definition of this.discoverSingletonDefinitions(spec)) {
             await this.ensureTargetNamespace(definition.registryNamespace);
             const singletonInstanceName = getSingletonInstanceName(definition.id);
-            const singletonFactory = definition.composition.factory('kro', {
-                namespace: definition.registryNamespace,
-                waitForReady: true,
-                ...(this.factoryOptions.timeout !== undefined
-                    ? { timeout: this.factoryOptions.timeout }
-                    : {}),
-                ...(this.factoryOptions.kubeConfig !== undefined
-                    ? { kubeConfig: this.factoryOptions.kubeConfig }
-                    : {}),
-                ...(this.factoryOptions.skipTLSVerify !== undefined
-                    ? { skipTLSVerify: this.factoryOptions.skipTLSVerify }
-                    : {}),
-            });
+            const singletonFactory = this.singletonFactoryFor(definition);
             try {
                 this.logger.info('Ensuring singleton owner boundary', {
                     singletonId: definition.id,
@@ -542,7 +534,6 @@ export class KroResourceFactoryImpl {
         const deploymentContext = {
             kubernetesApi: createBunCompatibleKubernetesObjectApi(kubeConfig),
             kubeConfig: kubeConfig,
-            ...(this.alchemyScope && { alchemyScope: this.alchemyScope }),
             namespace: this.namespace,
             deployedResources: new Map(), // Empty for pre-RGD execution
             resolveReference: async (ref) => {
@@ -653,78 +644,6 @@ export class KroResourceFactoryImpl {
             await deploymentEngine.dispose();
         }
     }
-    /**
-     * Deploy using type-safe alchemy resource wrapping
-     *
-     * In alchemy mode, the RGD gets one typed alchemy Resource and each instance gets another
-     */
-    async deployWithAlchemy(spec, instanceNameOverride, singletonSpecFingerprint) {
-        validateAlchemyScope(this.alchemyScope, 'KRO Alchemy deployment');
-        const alchemyScope = this.alchemyScope;
-        // Use static registration functions
-        // Create deployer instance using DirectDeploymentEngine with KRO mode
-        const kroEngine = new DirectDeploymentEngine(this.getKubeConfig(), undefined, undefined, DeploymentMode.KRO);
-        const kubeConfigOptions = this.extractKubeConfigOptionsForAlchemy();
-        const kroDeletion = this.createAlchemyKroDeletionOptions();
-        try {
-            // 1. Ensure RGD is deployed via alchemy (once per factory). Reuse the
-            // normal serializer so externalRef/forEach/includeWhen/readyWhen and
-            // singleton owner boundaries match non-Alchemy KRO deploys.
-            const rgdManifest = yaml.load(this.buildRgdYaml());
-            // Register RGD type dynamically
-            const rgdFactory = this.rgdProvider ??
-                (await import('../../factories/kro/resource-graph-definition.js')).resourceGraphDefinition;
-            const rgdEnhanced = rgdFactory(rgdManifest);
-            const bridge = this.alchemyBridge ?? (await import('../../alchemy/deployment.js'));
-            const RGDProvider = bridge.ensureResourceTypeRegistered(rgdEnhanced);
-            const rgdId = bridge.createAlchemyResourceId(rgdEnhanced, this.namespace);
-            await alchemyScope.run(async () => {
-                await RGDProvider(rgdId, {
-                    resource: rgdEnhanced,
-                    namespace: this.namespace,
-                    deploymentStrategy: 'kro',
-                    kubeConfigOptions,
-                    kroDeletion,
-                    options: {
-                        waitForReady: true,
-                        timeout: DEFAULT_RGD_TIMEOUT, // RGD should be ready quickly
-                    },
-                });
-            });
-            await this.waitForCRDReadyWithEngine(kroEngine);
-            // 2. Create instance via alchemy (once per deploy call)
-            await this.ensureTargetNamespace();
-            const instanceName = instanceNameOverride ?? generateInstanceName(spec, this.name);
-            const crdInstanceManifest = this.createCustomResourceInstance(instanceName, spec, singletonSpecFingerprint);
-            // Register CRD instance type dynamically
-            // Cast required: crdInstanceManifest is a plain KubernetesResource, but alchemy functions
-            // expect Enhanced<unknown, unknown>. They only access kind/metadata.name for type inference.
-            const crdAsEnhanced = crdInstanceManifest;
-            const CRDInstanceProvider = bridge.ensureResourceTypeRegistered(crdAsEnhanced);
-            const instanceId = bridge.createAlchemyResourceId(crdAsEnhanced, this.namespace);
-            await alchemyScope.run(async () => {
-                await CRDInstanceProvider(instanceId, {
-                    resource: crdAsEnhanced,
-                    namespace: this.namespace,
-                    deploymentStrategy: 'kro',
-                    kubeConfigOptions,
-                    kroDeletion,
-                    options: {
-                        waitForReady: false,
-                        timeout: this.factoryOptions.timeout ?? DEFAULT_DEPLOYMENT_TIMEOUT,
-                    },
-                });
-            });
-            if (this.factoryOptions.waitForReady ?? true) {
-                await this.waitForKroInstanceReady(instanceName, this.factoryOptions.timeout || DEFAULT_KRO_INSTANCE_TIMEOUT);
-            }
-            // Create Enhanced proxy for the deployed instance
-            return await this.createEnhancedProxy(spec, instanceName);
-        }
-        finally {
-            await kroEngine.dispose();
-        }
-    }
     /**
      * Get all deployed instances
      */
@@ -969,41 +888,106 @@ export class KroResourceFactoryImpl {
         // KRO's finalizer processing handles deleting all child resources
         // (including Namespaces) via its applyset — no manual cleanup needed.
     }
-    extractKubeConfigOptionsForAlchemy() {
-        const kc = this.getKubeConfig();
-        const cluster = kc.getCurrentCluster();
-        const user = typeof kc.getCurrentUser === 'function' ? kc.getCurrentUser() : undefined;
-        const context = typeof kc.getCurrentContext === 'function' ? kc.getCurrentContext() : undefined;
-        const finalSkipTLS = this.factoryOptions.skipTLSVerify === true ? true : (cluster?.skipTLSVerify ?? false);
-        return {
-            skipTLSVerify: finalSkipTLS,
-            ...(cluster?.server && { server: cluster.server }),
-            ...(context && { context }),
-            ...(cluster && {
-                cluster: {
-                    name: cluster.name,
-                    server: cluster.server,
-                    skipTLSVerify: finalSkipTLS,
-                    ...(cluster.caData && { caData: cluster.caData }),
-                    ...(cluster.caFile && { caFile: cluster.caFile }),
-                },
-            }),
-            ...(user && {
-                user: {
-                    name: user.name,
-                    ...(user.token && { token: user.token }),
-                    ...(user.certData && { certData: user.certData }),
-                    ...(user.certFile && { certFile: user.certFile }),
-                    ...(user.keyData && { keyData: user.keyData }),
-                    ...(user.keyFile && { keyFile: user.keyFile }),
-                    ...(user.exec ? { exec: user.exec } : {}),
-                    ...(user.authProvider
-                        ? { authProvider: user.authProvider }
-                        : {}),
+    /**
+     * Emit this factory's KRO deployment as declarative alchemy **v2** resources — the v2
+     * analog of the removed imperative `deployWithAlchemy(scope)`. Returns, in dependency order, a
+     * declaration for each discovered **singleton owner** (its own RGD + instance — mirroring
+     * `ensureSingletonOwners` in the imperative `deploy()` path), then the **RGD** (shared, deployed
+     * once), then the **CR instance** (one per `spec`, which `dependsOn` the RGD + the singletons),
+     * matching the old integration's per-resource state granularity. The caller instantiates
+     * each with `KroResource` inside their Stack (RGD first so reverse-topo removes the
+     * instance before the shared RGD):
+     *
+     * ```ts
+     * for (const { id, props } of await factory.toAlchemyResources(spec)) {
+     *   yield* KroResource(id, props);
+     * }
+     * ```
+     *
+     * Each declaration carries serialized `kubeConfigOptions` (so reconcile can reconnect to the
+     * cluster after state rehydration) and `kroDeletion` (so delete is finalizer-safe / shared-RGD
+     * aware). The actual deploy/teardown runs in `kroProvider`'s reconcile/delete.
+     */
+    async toAlchemyResources(spec, opts) {
+        const kubeConfigOptions = this.extractKubeConfigOptionsForAlchemy();
+        const kroDeletion = this.createAlchemyKroDeletionOptions();
+        // 0. Singleton owners. The imperative `deploy()` ensures shared singleton owners (each its own
+        // RGD + instance, in its registry namespace) via `ensureSingletonOwners` BEFORE the main
+        // instance; emit them as declarations too so the declarative path has the same boundaries.
+        // Their deterministic ids/names mean alchemy dedupes a singleton shared across compositions.
+        // (The runtime spec-drift check from `ensureSingletonOwners` is omitted here — `toAlchemyResources`
+        // stays cluster-free — but the spec-fingerprint annotation it relied on is still emitted.)
+        const singletonDeclarations = [];
+        const singletonInstanceIds = [];
+        for (const definition of this.discoverSingletonDefinitions(spec)) {
+            const singletonFactory = this.singletonFactoryFor(definition);
+            try {
+                const decls = await singletonFactory.toAlchemyResources(definition.spec, {
+                    instanceNameOverride: getSingletonInstanceName(definition.id),
+                    singletonSpecFingerprint: singletonSpecFingerprintAnnotationValue(definition.specFingerprint),
+                });
+                singletonDeclarations.push(...decls);
+                // `toAlchemyResources` returns the owner's OWN CR instance LAST (after any of ITS nested
+                // singletons + its RGD), so the consumer must wait on `decls[last]` — using "first decl
+                // with a dependency" would wrongly point at a nested singleton's instance.
+                const ownerInstance = decls[decls.length - 1];
+                if (ownerInstance)
+                    singletonInstanceIds.push(ownerInstance.id);
+            }
+            finally {
+                await singletonFactory.dispose?.();
+            }
+        }
+        // 1. RGD declaration (deployed once per factory; shared by all instances). Reuse the normal
+        // serializer so externalRef/forEach/includeWhen/readyWhen + singleton boundaries match
+        // non-alchemy KRO deploys.
+        const rgdManifest = yaml.load(this.buildRgdYaml());
+        const rgdFactory = this.rgdProvider ??
+            (await import('../../factories/kro/resource-graph-definition.js')).resourceGraphDefinition;
+        const rgdEnhanced = rgdFactory(rgdManifest);
+        const rgdId = createAlchemyResourceId(rgdEnhanced, this.namespace);
+        const rgdDeclaration = {
+            id: rgdId,
+            dependsOn: [],
+            props: {
+                resource: rgdEnhanced,
+                namespace: this.namespace,
+                deploymentStrategy: 'kro',
+                kubeConfigOptions,
+                kroDeletion,
+                options: { waitForReady: true, timeout: DEFAULT_RGD_TIMEOUT },
+            },
+        };
+        // 2. CR instance declaration (one per deploy call). Depends on the RGD so alchemy applies the
+        // instance only after the RGD's CRD is established (else the CR apply races a missing kind).
+        const instanceName = opts?.instanceNameOverride ?? generateInstanceName(spec, this.name);
+        const crdInstanceManifest = this.createCustomResourceInstance(instanceName, spec, opts?.singletonSpecFingerprint);
+        // Cast: a plain KubernetesResource is fine — the alchemy path only reads kind/metadata.
+        const crdAsEnhanced = crdInstanceManifest;
+        const instanceDeclaration = {
+            id: createAlchemyResourceId(crdAsEnhanced, this.namespace),
+            // Wait for the RGD's CRD AND for any singleton owners (mirrors `ensureSingletonOwners` running
+            // before the main deploy), so the instance applies only once its dependencies exist.
+            dependsOn: [rgdId, ...singletonInstanceIds],
+            props: {
+                resource: crdAsEnhanced,
+                namespace: this.namespace,
+                deploymentStrategy: 'kro',
+                kubeConfigOptions,
+                kroDeletion,
+                options: {
+                    waitForReady: false,
+                    timeout: this.factoryOptions.timeout ?? DEFAULT_DEPLOYMENT_TIMEOUT,
                 },
-            }),
+            },
         };
+        return [...singletonDeclarations, rgdDeclaration, instanceDeclaration];
+    }
+    /** Serialize the factory's cluster connection so an alchemy resource can reconnect after rehydration. */
+    extractKubeConfigOptionsForAlchemy() {
+        return extractSerializableKubeConfigOptions(this.getKubeConfig(), this.factoryOptions.skipTLSVerify === true ? true : undefined);
     }
+    /** Build the finalizer-safe, shared-RGD-aware deletion metadata for this factory's instances. */
     createAlchemyKroDeletionOptions() {
         return {
             apiVersion: this.schemaDefinition.apiVersion,
@@ -1024,7 +1008,6 @@ export class KroResourceFactoryImpl {
         return {
             name: this.name,
             mode: this.mode,
-            isAlchemyManaged: this.isAlchemyManaged,
             namespace: this.namespace,
             instanceCount: instances.length,
             health: rgdStatus.phase === 'ready' ? 'healthy' : 'degraded',
@@ -1144,8 +1127,17 @@ export class KroResourceFactoryImpl {
         }
         const statusOverrides = this.factoryOptions.compositionAnalysis?.statusOverrides ?? [];
         if (statusOverrides.length > 0) {
-            kroSchema.status ??= {};
+            // Only resource-referencing (dynamic) overrides belong in the KRO schema;
+            // schema-only ones (e.g. `spec.x ? a : b`) are rejected by KRO ("unknown
+            // identifiers: [schema]") and are hydrated client-side instead, like any
+            // other static status field.
+            const resourceIdList = Object.keys(aspectResources);
+            const nestedCel = this.getNestedStatusCel();
+            const nestedCelForClassification = nestedCel && Object.keys(nestedCel).length > 0 ? nestedCel : undefined;
             for (const override of statusOverrides) {
+                if (isStaticExpression(override.celExpression, nestedCelForClassification, resourceIdList))
+                    continue;
+                kroSchema.status ??= {};
                 const yamlSafe = override.celExpression.replace(/"([^"\\]*)"/g, "'$1'");
                 kroSchema.status[override.propertyPath] = yamlSafe;
             }