typekro 0.13.0 → 0.15.0

package/dist/alchemy/types.d.ts

@@ -4,9 +4,8 @@
  * This module provides type definitions for alchemy integration
  * with TypeKro resources.
  */
-import type { Resource as AlchemyResource } from 'alchemy';
 import type { KubernetesClientConfig } from '../core/kubernetes/client-provider.js';
-import type { DeploymentOptions } from '../core/types/deployment.js';
+import type { DeployedResource, DeploymentOptions } from '../core/types/deployment.js';
 import type { Enhanced } from '../core/types/kubernetes.js';
 import type { KroDeletionOptions } from './kro-delete.js';
 /**
@@ -14,9 +13,11 @@ import type { KroDeletionOptions } from './kro-delete.js';
  */
 export interface TypeKroDeployer {
     /**
-     * Deploy a TypeKro resource to Kubernetes
+     * Deploy a TypeKro resource to Kubernetes. `seedResources` (direct mode) supplies the live state
+     * of resources deployed elsewhere (e.g. sibling alchemy resources) so this resource's
+     * cross-resource references/CEL resolve without redeploying them.
      */
-    deploy<T extends Enhanced<any, any>>(resource: T, options: DeploymentOptions): Promise<T>;
+    deploy<T extends Enhanced<any, any>>(resource: T, options: DeploymentOptions, seedResources?: DeployedResource[]): Promise<T>;
     /**
      * Delete a TypeKro resource from Kubernetes
      */
@@ -46,18 +47,67 @@ export interface TypeKroResourceProps<T extends Enhanced<any, any>> {
      */
     deploymentStrategy: 'direct' | 'kro';
     /**
-     * Serializable kubeConfig options
+     * The resource's logical id within its composition graph (e.g. `webappDeployment`) — the id
+     * sibling resources' `KubernetesRef`s point at. Surfaced on the output so dependents can seed
+     * reference resolution against this resource's live state. Set by `toAlchemyResources`.
+     */
+    resourceId?: string;
+    /**
+     * Serializable kubeConfig options used to reach the cluster (and to reconnect on a rehydrated
+     * delete). Echoed onto the output so a state-driven delete works.
+     *
+     * ⚠️ SECURITY: alchemy persists props + output to its state store, so these options are written
+     * to state. If they carry static secrets — `user.token` / `user.certData` / `user.keyData` — those
+     * land in state (e.g. plaintext for the local/HTTP stores). Prefer re-derived auth (`user.exec`
+     * such as `aws eks get-token`, or `authProvider`), which is a command spec rather than a secret,
+     * and use a secured state backend. See {@link extractSerializableKubeConfigOptions}.
      */
     kubeConfigOptions?: SerializableKubeConfigOptions;
     /** Optional preconfigured deployer. Runtime-only; do not rely on this surviving Alchemy rehydration. */
     deployer?: TypeKroDeployer;
     /** Serializable metadata used to preserve finalizer-safe KRO teardown after Alchemy rehydration. */
     kroDeletion?: KroDeletionOptions;
+    /**
+     * Resolved outputs of the resources this one depends on. Two jobs:
+     *
+     *  1. **Ordering** — because each entry traces back (via an alchemy `Output`) to another
+     *     resource, alchemy deploys those first. KRO uses this so the CR instance waits for its
+     *     RGD's CRD; direct mode uses it to honor the composition's dependency graph.
+     *  2. **Reference resolution (direct mode)** — each entry's `deployedResource` is the live
+     *     dependency, so the reconcile can resolve this resource's cross-resource `KubernetesRef`s
+     *     against already-deployed siblings before applying the (now concrete) single manifest.
+     *
+     * Populated by {@link AlchemyResourceDeclaration} + the `materializeAlchemyResources` helper,
+     * not by hand. By the time `reconcile` runs, alchemy has resolved these to concrete values.
+     */
+    dependencies?: TypeKroResource<Enhanced<unknown, unknown>>[];
     /**
      * Optional deployment options
      */
     options?: Partial<Omit<DeploymentOptions, 'mode' | 'namespace'>>;
 }
+/**
+ * A single declarative alchemy v2 resource to instantiate: a stable `id` plus the
+ * `props` to pass to `KroResource`. Produced by a factory's `toAlchemyResources(spec)`
+ * (the v2 analog of the removed imperative `deployWithAlchemy`) so callers can fan a
+ * KRO factory out into its independent state entries (the RGD + each CR instance):
+ *
+ * ```ts
+ * for (const { id, props } of await factory.toAlchemyResources(spec)) {
+ *   yield* KroResource(id, props);
+ * }
+ * ```
+ */
+export interface AlchemyResourceDeclaration {
+    readonly id: string;
+    readonly props: TypeKroResourceProps<Enhanced<unknown, unknown>>;
+    /**
+     * Ids of the other declarations (in the same array) this one must deploy after. The
+     * declarations are returned topologically sorted, and `materializeAlchemyResources` turns
+     * these into alchemy `Output` dependencies (ordering + direct-mode reference resolution).
+     */
+    readonly dependsOn: readonly string[];
+}
 /**
  * Alchemy resource state structure
  */
@@ -68,18 +118,36 @@ export interface AlchemyResourceState {
     [key: string]: unknown;
 }
 /**
- * Output returned after TypeKro resource deployment through alchemy
- * Following alchemy pattern: interface name matches exported resource name
+ * Output returned after TypeKro resource deployment through alchemy.
+ *
+ * Under alchemy v2 a resource's output is a plain, serializable shape (the value
+ * `reconcile` returns and alchemy persists to state) — not an extension of a
+ * framework `Resource` type as it was under v1.
  */
-export interface TypeKroResource<T extends Enhanced<any, any>> extends AlchemyResource<string> {
+export interface TypeKroResource<T extends Enhanced<any, any>> {
     /**
      * The original TypeKro resource
      */
     resource: T;
+    /**
+     * The resource's logical composition-graph id (mirrors {@link TypeKroResourceProps.resourceId}).
+     * Lets a dependent reconcile match this resource against its `KubernetesRef`s when seeding
+     * direct-mode reference resolution. Undefined for resources not produced via `toAlchemyResources`.
+     */
+    resourceId?: string;
     /**
      * The namespace the resource was deployed to
      */
     namespace: string;
+    /**
+     * Persisted delete-time metadata: how the resource was deployed + how to reach/tear it down.
+     * Echoed from the props so a state-driven `delete` (no live `news`) can reconstruct them.
+     * ⚠️ SECURITY: `kubeConfigOptions` is persisted to alchemy state — see the note on
+     * {@link TypeKroResourceProps.kubeConfigOptions}.
+     */
+    deploymentStrategy?: 'direct' | 'kro';
+    kubeConfigOptions?: SerializableKubeConfigOptions;
+    kroDeletion?: KroDeletionOptions;
     /**
      * The deployed resource with live status from the cluster
      */

package/dist/alchemy/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/alchemy/types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,QAAQ,IAAI,eAAe,EAAE,MAAM,SAAS,CAAC;AAC3D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,6BAA6B,CAAC;AAC5D,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAE1D;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,MAAM,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAE1F;;OAEG;IACH,MAAM,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE7F,6DAA6D;IAC7D,OAAO,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC3B;AAED;;;GAGG;AACH,MAAM,MAAM,6BAA6B,GAAG,sBAAsB,CAAC;AAEnE;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC;IAChE;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC;IAEZ;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,kBAAkB,EAAE,QAAQ,GAAG,KAAK,CAAC;IAErC;;OAEG;IACH,iBAAiB,CAAC,EAAE,6BAA6B,CAAC;IAElD,wGAAwG;IACxG,QAAQ,CAAC,EAAE,eAAe,CAAC;IAE3B,oGAAoG;IACpG,WAAW,CAAC,EAAE,kBAAkB,CAAC;IAEjC;;OAEG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,iBAAiB,EAAE,MAAM,GAAG,WAAW,CAAC,CAAC,CAAC;CAClE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,SAAS,CAAC;IAClD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB;AAED;;;GAGG;AACH,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,QAAQ,CAAC,GAAG,EAAE,GAAG,CAAC,CAAE,SAAQ,eAAe,CAAC,MAAM,CAAC;IAC5F;;OAEG;IACH,QAAQ,EAAE,CAAC,CAAC;IAEZ;;OAEG;IACH,SAAS,EAAE,MAAM,CAAC;IAElB;;OAEG;IACH,gBAAgB,EAAE,CAAC,CAAC;IAEpB;;OAEG;IACH,KAAK,EAAE,OAAO,CAAC;IAEf;;OAEG;IACH,UAAU,EAAE,MAAM,CAAC;CACpB"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/alchemy/types.ts"],"names":[],"mappings":"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"}

package/dist/alchemy/wrapper.d.ts

@@ -1,16 +1,7 @@
 /**
  * Alchemy Integration Utilities
- *
- * This file contains utility functions that align with the dynamic registration approach.
- * Static resource registration functions have been removed to avoid conflicts.
  */
 import { generateDeterministicResourceId as _generateDeterministicResourceId } from '../core/resources/id.js';
-/**
- * Utility to check if a factory is alchemy-managed
- */
-export declare function isAlchemyWrapped(factory: unknown): factory is {
-    isAlchemyManaged: true;
-};
 /**
  * Re-export utility function for deterministic resource ID generation
  */

package/dist/alchemy/wrapper.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/alchemy/wrapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,+BAA+B,IAAI,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAE9G;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,IAAI;IAAE,gBAAgB,EAAE,IAAI,CAAA;CAAE,CAQxF;AAED;;GAEG;AACH,eAAO,MAAM,+BAA+B,yCAAmC,CAAC"}
+{"version":3,"file":"wrapper.d.ts","sourceRoot":"","sources":["../../src/alchemy/wrapper.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,+BAA+B,IAAI,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAE9G;;GAEG;AACH,eAAO,MAAM,+BAA+B,yCAAmC,CAAC"}

package/dist/alchemy/wrapper.js

@@ -1,24 +1,9 @@
 /**
  * Alchemy Integration Utilities
- *
- * This file contains utility functions that align with the dynamic registration approach.
- * Static resource registration functions have been removed to avoid conflicts.
  */
 import { generateDeterministicResourceId as _generateDeterministicResourceId } from '../core/resources/id.js';
-/**
- * Utility to check if a factory is alchemy-managed
- */
-export function isAlchemyWrapped(factory) {
-    return (factory !== null &&
-        factory !== undefined &&
-        typeof factory === 'object' &&
-        'isAlchemyManaged' in factory &&
-        factory.isAlchemyManaged === true);
-}
 /**
  * Re-export utility function for deterministic resource ID generation
  */
 export const generateDeterministicResourceId = _generateDeterministicResourceId;
-// All static resource registration functions have been removed to align with
-// the dynamic registration approach using ensureResourceTypeRegistered()
 //# sourceMappingURL=wrapper.js.map

package/dist/alchemy/wrapper.js.map

@@ -1 +1 @@
-{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/alchemy/wrapper.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,+BAA+B,IAAI,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAE9G;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,OAAgB;IAC/C,OAAO,CACL,OAAO,KAAK,IAAI;QAChB,OAAO,KAAK,SAAS;QACrB,OAAO,OAAO,KAAK,QAAQ;QAC3B,kBAAkB,IAAI,OAAO;QAC7B,OAAO,CAAC,gBAAgB,KAAK,IAAI,CAClC,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,gCAAgC,CAAC;AAEhF,6EAA6E;AAC7E,yEAAyE"}
+{"version":3,"file":"wrapper.js","sourceRoot":"","sources":["../../src/alchemy/wrapper.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,+BAA+B,IAAI,gCAAgC,EAAE,MAAM,yBAAyB,CAAC;AAE9G;;GAEG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,gCAAgC,CAAC"}

package/dist/core/constants/brands.d.ts

@@ -5,5 +5,5 @@
  * New code within `src/utils/` should import directly from `../../shared/brands.js`
  * to maintain the clean dependency direction: `shared/ <-- utils/ <-- core/`.
  */
-export { CALLABLE_COMPOSITION_BRAND, CEL_EXPRESSION_BRAND, CONTAINER_IMAGE_REF_BRAND, KUBERNETES_REF_BRAND, KUBERNETES_REF_MARKER_FIELD_PATH_SOURCE, KUBERNETES_REF_MARKER_PATTERN, KUBERNETES_REF_MARKER_RESOURCE_ID_SOURCE, KUBERNETES_REF_MARKER_SOURCE, KUBERNETES_REF_SCHEMA_MARKER_SOURCE, MIXED_TEMPLATE_BRAND, NESTED_COMPOSITION_BRAND, SINGLETON_HANDLE_BRAND, } from '../../shared/brands.js';
+export { CALLABLE_COMPOSITION_BRAND, CEL_EXPRESSION_BRAND, KUBERNETES_REF_BRAND, KUBERNETES_REF_MARKER_FIELD_PATH_SOURCE, KUBERNETES_REF_MARKER_PATTERN, KUBERNETES_REF_MARKER_RESOURCE_ID_SOURCE, KUBERNETES_REF_MARKER_SOURCE, KUBERNETES_REF_SCHEMA_MARKER_SOURCE, MIXED_TEMPLATE_BRAND, NESTED_COMPOSITION_BRAND, SINGLETON_HANDLE_BRAND, } from '../../shared/brands.js';
 //# sourceMappingURL=brands.d.ts.map

package/dist/core/constants/brands.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"brands.d.ts","sourceRoot":"","sources":["../../../src/core/constants/brands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,uCAAuC,EACvC,6BAA6B,EAC7B,wCAAwC,EACxC,4BAA4B,EAC5B,mCAAmC,EACnC,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"brands.d.ts","sourceRoot":"","sources":["../../../src/core/constants/brands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,uCAAuC,EACvC,6BAA6B,EAC7B,wCAAwC,EACxC,4BAA4B,EAC5B,mCAAmC,EACnC,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC"}

package/dist/core/constants/brands.js

@@ -5,5 +5,5 @@
  * New code within `src/utils/` should import directly from `../../shared/brands.js`
  * to maintain the clean dependency direction: `shared/ <-- utils/ <-- core/`.
  */
-export { CALLABLE_COMPOSITION_BRAND, CEL_EXPRESSION_BRAND, CONTAINER_IMAGE_REF_BRAND, KUBERNETES_REF_BRAND, KUBERNETES_REF_MARKER_FIELD_PATH_SOURCE, KUBERNETES_REF_MARKER_PATTERN, KUBERNETES_REF_MARKER_RESOURCE_ID_SOURCE, KUBERNETES_REF_MARKER_SOURCE, KUBERNETES_REF_SCHEMA_MARKER_SOURCE, MIXED_TEMPLATE_BRAND, NESTED_COMPOSITION_BRAND, SINGLETON_HANDLE_BRAND, } from '../../shared/brands.js';
+export { CALLABLE_COMPOSITION_BRAND, CEL_EXPRESSION_BRAND, KUBERNETES_REF_BRAND, KUBERNETES_REF_MARKER_FIELD_PATH_SOURCE, KUBERNETES_REF_MARKER_PATTERN, KUBERNETES_REF_MARKER_RESOURCE_ID_SOURCE, KUBERNETES_REF_MARKER_SOURCE, KUBERNETES_REF_SCHEMA_MARKER_SOURCE, MIXED_TEMPLATE_BRAND, NESTED_COMPOSITION_BRAND, SINGLETON_HANDLE_BRAND, } from '../../shared/brands.js';
 //# sourceMappingURL=brands.js.map

package/dist/core/constants/brands.js.map

@@ -1 +1 @@
-{"version":3,"file":"brands.js","sourceRoot":"","sources":["../../../src/core/constants/brands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,yBAAyB,EACzB,oBAAoB,EACpB,uCAAuC,EACvC,6BAA6B,EAC7B,wCAAwC,EACxC,4BAA4B,EAC5B,mCAAmC,EACnC,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC"}
+{"version":3,"file":"brands.js","sourceRoot":"","sources":["../../../src/core/constants/brands.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,0BAA0B,EAC1B,oBAAoB,EACpB,oBAAoB,EACpB,uCAAuC,EACvC,6BAA6B,EAC7B,wCAAwC,EACxC,4BAA4B,EAC5B,mCAAmC,EACnC,oBAAoB,EACpB,wBAAwB,EACxB,sBAAsB,GACvB,MAAM,wBAAwB,CAAC"}

package/dist/core/containers/image.d.ts

@@ -1,65 +1,62 @@
 /**
  * Container Image Utility
  *
- * `container()` declares a container image built from source and pushed to a registry, as a
- * FIRST-CLASS typekro utility. It is defined at program scope — OUTSIDE a `kubernetesComposition` —
- * because an image is a build-time artifact with no dependency on cluster state; it should never be a
- * node in the cluster resource graph. Resources WITHIN a composition reference its `.imageUri`.
+ * `container()` declares a container image built from source and pushed to a registry. It is the
+ * high-level front door over {@link buildContainer}: a memoized async builder that resolves to a
+ * SHAPED result (`{ imageUri, repository, tag }`) so callers can use the full URI for a resource's
+ * image field OR the split `repository`/`tag` for a Helm chart's image values — without re-splitting.
  *
- * `.imageUri` is a `ContainerImageRef` (a distinct brand, NOT a `KubernetesRef`): typekro resolves it
- * CLIENT-SIDE to a literal image URI before apply (direct mode) / RGD serialization (kro mode), by
- * delegating to the existing {@link buildContainer} — once per container identity. Kro never sees a
- * build, only a literal image string.
+ * An image build is an async, client-side, pre-deploy side effect, so `container()` is honest about
+ * that: you `await` it. It is NOT a deferred reference — resolve images in (async) setup code before
+ * composing, then feed the resulting literals into resources or chart values.
+ *
+ * Memoization: the build is keyed by container identity (`id ?? imageName`) and cached, so awaiting
+ * the same container many times (e.g. several deployments sharing one image) builds it exactly ONCE.
  *
  * @example
  * ```typescript
  * import { container } from 'typekro/containers';
  *
- * // Defined OUTSIDE the composition:
- * const appImage = container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * const img = await container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * // img.imageUri  → '123.dkr.ecr.us-east-1.amazonaws.com/app:sha-abc'
+ * // img.repository → '123.dkr.ecr.us-east-1.amazonaws.com/app'   img.tag → 'sha-abc'
  *
- * // Referenced WITHIN one:
- * kubernetesComposition(def, () => {
- *   Deployment({ name: 'app', image: appImage.imageUri, ports: [{ containerPort: 3000 }] });
- * });
+ * Deployment({ name: 'app', image: img.imageUri, ports: [{ containerPort: 3000 }] });
+ * // or for a Helm chart's split image values: { repository: img.repository, tag: img.tag }
  * ```
  */
-import { CONTAINER_IMAGE_REF_BRAND } from '../constants/brands.js';
-import type { ContainerBuildOptions } from './registries/types.js';
-/**
- * A reference to a container image's URI. Resolved client-side to a literal string (the built +
- * pushed image URI) before apply / RGD serialization — distinct from a `KubernetesRef`, which is a
- * cluster-state reference serialized to CEL.
- */
-export interface ContainerImageRef<T extends string = string> {
-    readonly [CONTAINER_IMAGE_REF_BRAND]: true;
-    /** Stable identity — multiple references to the same container build the image only ONCE. */
-    readonly containerId: string;
-    /** The build spec, carried inline so the resolver is self-contained (delegates to `buildContainer`). */
-    readonly buildOptions: ContainerBuildOptions;
-    readonly _type?: T;
-}
-/** A first-class container image: defined outside a composition, referenced within one. */
+import type { ContainerBuildOptions, ContainerBuildResult } from './registries/types.js';
+/** A built container image, resolved to a literal — both the full URI and its split parts. */
 export interface ContainerImage {
-    /**
-     * The image-URI reference — assign to any resource image field (e.g. a container's `image`). Typed
-     * as `string` so it's assignable to plain string fields, exactly like typekro's schema/resource
-     * refs; at RUNTIME it is a branded {@link ContainerImageRef} that the resolver substitutes with the
-     * built image URI at deploy time. Use {@link isContainerImageRef} to detect it.
-     */
+    /** Full image URI, e.g. `123.dkr.ecr.us-east-1.amazonaws.com/app:sha-abc`. */
     readonly imageUri: string;
+    /** The URI without the tag, e.g. `123.dkr.ecr.us-east-1.amazonaws.com/app`. */
+    readonly repository: string;
+    /** The tag, e.g. `sha-abc`. */
+    readonly tag: string;
 }
 /** Options for {@link container}: the {@link ContainerBuildOptions} plus an optional stable identity. */
 export interface ContainerOptions extends ContainerBuildOptions {
-    /** Stable identity for dedup across references; defaults to `imageName`. Set when two containers share one. */
+    /** Stable identity for build memoization; defaults to `imageName`. Set when two containers share one. */
     id?: string;
 }
 /**
- * Declare a container image as a first-class typekro utility (see the module doc). Returns a handle
- * whose `.imageUri` is referenced from resources; the build (via {@link buildContainer}) happens once
- * at deploy time and the literal URI is substituted before apply / serialization.
+ * Split a full image URI into `{ repository, tag }`. Handles digest form (`repo@sha256:…`) and tag
+ * form (`repo:tag`), registry-port-colon aware (a colon in `host:port/...` is not the tag separator).
+ */
+export declare function splitImageUri(uri: string): {
+    repository: string;
+    tag: string;
+};
+/** Test seam: the builder `container()` delegates to (defaults to the real {@link buildContainer}). */
+type Builder = (options: ContainerBuildOptions) => Promise<ContainerBuildResult>;
+/**
+ * Build a container image (delegating to {@link buildContainer}) and resolve to its shaped result.
+ * Memoized by identity — see the module doc. `build` is an injectable test seam; production callers
+ * pass only `options`.
  */
-export declare function container(options: ContainerOptions): ContainerImage;
-/** Type guard: is `value` a {@link ContainerImageRef} (the `.imageUri` of a `container()`)? */
-export declare function isContainerImageRef(value: unknown): value is ContainerImageRef;
+export declare function container(options: ContainerOptions, build?: Builder): Promise<ContainerImage>;
+/** Clear the build memoization cache. Intended for tests/long-lived processes that need a rebuild. */
+export declare function clearContainerCache(): void;
+export {};
 //# sourceMappingURL=image.d.ts.map

package/dist/core/containers/image.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/core/containers/image.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AACnE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,uBAAuB,CAAC;AAEnE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB,CAAC,CAAC,SAAS,MAAM,GAAG,MAAM;IAC1D,QAAQ,CAAC,CAAC,yBAAyB,CAAC,EAAE,IAAI,CAAC;IAC3C,6FAA6F;IAC7F,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,wGAAwG;IACxG,QAAQ,CAAC,YAAY,EAAE,qBAAqB,CAAC;IAC7C,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;CACpB;AAED,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B;;;;;OAKG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAED,yGAAyG;AACzG,MAAM,WAAW,gBAAiB,SAAQ,qBAAqB;IAC7D,+GAA+G;IAC/G,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,gBAAgB,GAAG,cAAc,CAWnE;AAED,+FAA+F;AAC/F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,iBAAiB,CAM9E"}
+{"version":3,"file":"image.d.ts","sourceRoot":"","sources":["../../../src/core/containers/image.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAGH,OAAO,KAAK,EAAE,qBAAqB,EAAE,oBAAoB,EAAE,MAAM,uBAAuB,CAAC;AAEzF,8FAA8F;AAC9F,MAAM,WAAW,cAAc;IAC7B,8EAA8E;IAC9E,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,+EAA+E;IAC/E,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,+BAA+B;IAC/B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;CACtB;AAED,yGAAyG;AACzG,MAAM,WAAW,gBAAiB,SAAQ,qBAAqB;IAC7D,yGAAyG;IACzG,EAAE,CAAC,EAAE,MAAM,CAAC;CACb;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAQ9E;AAKD,uGAAuG;AACvG,KAAK,OAAO,GAAG,CAAC,OAAO,EAAE,qBAAqB,KAAK,OAAO,CAAC,oBAAoB,CAAC,CAAC;AASjF;;;;GAIG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,gBAAgB,EACzB,KAAK,GAAE,OAAwB,GAC9B,OAAO,CAAC,cAAc,CAAC,CAQzB;AAED,sGAAsG;AACtG,wBAAgB,mBAAmB,IAAI,IAAI,CAE1C"}

package/dist/core/containers/image.js

@@ -1,51 +1,69 @@
 /**
  * Container Image Utility
  *
- * `container()` declares a container image built from source and pushed to a registry, as a
- * FIRST-CLASS typekro utility. It is defined at program scope — OUTSIDE a `kubernetesComposition` —
- * because an image is a build-time artifact with no dependency on cluster state; it should never be a
- * node in the cluster resource graph. Resources WITHIN a composition reference its `.imageUri`.
+ * `container()` declares a container image built from source and pushed to a registry. It is the
+ * high-level front door over {@link buildContainer}: a memoized async builder that resolves to a
+ * SHAPED result (`{ imageUri, repository, tag }`) so callers can use the full URI for a resource's
+ * image field OR the split `repository`/`tag` for a Helm chart's image values — without re-splitting.
  *
- * `.imageUri` is a `ContainerImageRef` (a distinct brand, NOT a `KubernetesRef`): typekro resolves it
- * CLIENT-SIDE to a literal image URI before apply (direct mode) / RGD serialization (kro mode), by
- * delegating to the existing {@link buildContainer} — once per container identity. Kro never sees a
- * build, only a literal image string.
+ * An image build is an async, client-side, pre-deploy side effect, so `container()` is honest about
+ * that: you `await` it. It is NOT a deferred reference — resolve images in (async) setup code before
+ * composing, then feed the resulting literals into resources or chart values.
+ *
+ * Memoization: the build is keyed by container identity (`id ?? imageName`) and cached, so awaiting
+ * the same container many times (e.g. several deployments sharing one image) builds it exactly ONCE.
  *
  * @example
  * ```typescript
  * import { container } from 'typekro/containers';
  *
- * // Defined OUTSIDE the composition:
- * const appImage = container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * const img = await container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * // img.imageUri  → '123.dkr.ecr.us-east-1.amazonaws.com/app:sha-abc'
+ * // img.repository → '123.dkr.ecr.us-east-1.amazonaws.com/app'   img.tag → 'sha-abc'
  *
- * // Referenced WITHIN one:
- * kubernetesComposition(def, () => {
- *   Deployment({ name: 'app', image: appImage.imageUri, ports: [{ containerPort: 3000 }] });
- * });
+ * Deployment({ name: 'app', image: img.imageUri, ports: [{ containerPort: 3000 }] });
+ * // or for a Helm chart's split image values: { repository: img.repository, tag: img.tag }
  * ```
  */
-import { CONTAINER_IMAGE_REF_BRAND } from '../constants/brands.js';
+import { buildContainer } from './build.js';
+/**
+ * Split a full image URI into `{ repository, tag }`. Handles digest form (`repo@sha256:…`) and tag
+ * form (`repo:tag`), registry-port-colon aware (a colon in `host:port/...` is not the tag separator).
+ */
+export function splitImageUri(uri) {
+    const at = uri.lastIndexOf('@');
+    if (at !== -1)
+        return { repository: uri.slice(0, at), tag: uri.slice(at + 1) };
+    const colon = uri.lastIndexOf(':');
+    const slash = uri.lastIndexOf('/');
+    return colon > slash
+        ? { repository: uri.slice(0, colon), tag: uri.slice(colon + 1) }
+        : { repository: uri, tag: 'latest' };
+}
+/** Build memoization, keyed by container identity (`id ?? imageName`) — builds each image once. */
+const buildCache = new Map();
+async function buildAndShape(options, build) {
+    const { id: _id, ...buildOptions } = options;
+    const result = await build({ ...buildOptions, tag: buildOptions.tag ?? 'content-hash' });
+    const { repository, tag } = splitImageUri(result.imageUri);
+    return { imageUri: result.imageUri, repository, tag };
+}
 /**
- * Declare a container image as a first-class typekro utility (see the module doc). Returns a handle
- * whose `.imageUri` is referenced from resources; the build (via {@link buildContainer}) happens once
- * at deploy time and the literal URI is substituted before apply / serialization.
+ * Build a container image (delegating to {@link buildContainer}) and resolve to its shaped result.
+ * Memoized by identity — see the module doc. `build` is an injectable test seam; production callers
+ * pass only `options`.
  */
-export function container(options) {
-    const { id, ...buildOptions } = options;
-    const containerId = id ?? buildOptions.imageName;
-    const ref = {
-        [CONTAINER_IMAGE_REF_BRAND]: true,
-        containerId,
-        buildOptions,
-    };
-    // Typed as `string` (assignable to any image field) but a branded ref at runtime — mirrors how
-    // typekro's schema/resource refs present as their underlying type while carrying runtime markers.
-    return { imageUri: ref };
+export function container(options, build = buildContainer) {
+    const key = options.id ?? options.imageName;
+    let pending = buildCache.get(key);
+    if (!pending) {
+        pending = buildAndShape(options, build);
+        buildCache.set(key, pending);
+    }
+    return pending;
 }
-/** Type guard: is `value` a {@link ContainerImageRef} (the `.imageUri` of a `container()`)? */
-export function isContainerImageRef(value) {
-    return (typeof value === 'object' &&
-        value !== null &&
-        value[CONTAINER_IMAGE_REF_BRAND] === true);
+/** Clear the build memoization cache. Intended for tests/long-lived processes that need a rebuild. */
+export function clearContainerCache() {
+    buildCache.clear();
 }
 //# sourceMappingURL=image.js.map

package/dist/core/containers/image.js.map

@@ -1 +1 @@
-{"version":3,"file":"image.js","sourceRoot":"","sources":["../../../src/core/containers/image.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,OAAO,EAAE,yBAAyB,EAAE,MAAM,wBAAwB,CAAC;AAkCnE;;;;GAIG;AACH,MAAM,UAAU,SAAS,CAAC,OAAyB;IACjD,MAAM,EAAE,EAAE,EAAE,GAAG,YAAY,EAAE,GAAG,OAAO,CAAC;IACxC,MAAM,WAAW,GAAG,EAAE,IAAI,YAAY,CAAC,SAAS,CAAC;IACjD,MAAM,GAAG,GAA8B;QACrC,CAAC,yBAAyB,CAAC,EAAE,IAAI;QACjC,WAAW;QACX,YAAY;KACb,CAAC;IACF,+FAA+F;IAC/F,kGAAkG;IAClG,OAAO,EAAE,QAAQ,EAAE,GAAwB,EAAE,CAAC;AAChD,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,mBAAmB,CAAC,KAAc;IAChD,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACb,KAAiC,CAAC,yBAAyB,CAAC,KAAK,IAAI,CACvE,CAAC;AACJ,CAAC"}
+{"version":3,"file":"image.js","sourceRoot":"","sources":["../../../src/core/containers/image.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAmB5C;;;GAGG;AACH,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,MAAM,EAAE,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IAChC,IAAI,EAAE,KAAK,CAAC,CAAC;QAAE,OAAO,EAAE,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC;IAC/E,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACnC,MAAM,KAAK,GAAG,GAAG,CAAC,WAAW,CAAC,GAAG,CAAC,CAAC;IACnC,OAAO,KAAK,GAAG,KAAK;QAClB,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,CAAC,KAAK,CAAC,CAAC,EAAE,KAAK,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,KAAK,CAAC,KAAK,GAAG,CAAC,CAAC,EAAE;QAChE,CAAC,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,EAAE,QAAQ,EAAE,CAAC;AACzC,CAAC;AAED,mGAAmG;AACnG,MAAM,UAAU,GAAG,IAAI,GAAG,EAAmC,CAAC;AAK9D,KAAK,UAAU,aAAa,CAAC,OAAyB,EAAE,KAAc;IACpE,MAAM,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,YAAY,EAAE,GAAG,OAAO,CAAC;IAC7C,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,EAAE,GAAG,YAAY,EAAE,GAAG,EAAE,YAAY,CAAC,GAAG,IAAI,cAAc,EAAE,CAAC,CAAC;IACzF,MAAM,EAAE,UAAU,EAAE,GAAG,EAAE,GAAG,aAAa,CAAC,MAAM,CAAC,QAAQ,CAAC,CAAC;IAC3D,OAAO,EAAE,QAAQ,EAAE,MAAM,CAAC,QAAQ,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;AACxD,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,SAAS,CACvB,OAAyB,EACzB,QAAiB,cAAc;IAE/B,MAAM,GAAG,GAAG,OAAO,CAAC,EAAE,IAAI,OAAO,CAAC,SAAS,CAAC;IAC5C,IAAI,OAAO,GAAG,UAAU,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IAClC,IAAI,CAAC,OAAO,EAAE,CAAC;QACb,OAAO,GAAG,aAAa,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;QACxC,UAAU,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC;AAED,sGAAsG;AACtG,MAAM,UAAU,mBAAmB;IACjC,UAAU,CAAC,KAAK,EAAE,CAAC;AACrB,CAAC"}

package/dist/core/containers/index.d.ts

@@ -5,25 +5,21 @@
  * Returns image URIs for use in TypeKro compositions.
  *
  * The low-level `buildContainer` builds + pushes imperatively and returns a URI. The higher-level
- * `container()` utility wraps it declaratively: define an image once at program scope and reference
- * its `.imageUri` from resources inside a composition — typekro builds it (via `buildContainer`) and
- * substitutes the literal URI at deploy time.
+ * `container()` is a memoized async builder that resolves to a SHAPED result (`{ imageUri,
+ * repository, tag }`) — `await` it in setup code, then feed the full URI to a resource's image field
+ * or the split `repository`/`tag` to a Helm chart's image values.
  *
  * @example
  * ```typescript
- * import { buildContainer, container } from 'typekro/containers';
+ * import { container } from 'typekro/containers';
  *
- * // Imperative (build now, get a URI):
- * const { imageUri } = await buildContainer({ context: './app', imageName: 'app', registry: { type: 'orbstack' } });
- *
- * // Declarative (defined outside a composition, referenced within):
- * const appImage = container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
- * // … later, inside a composition: Deployment({ image: appImage.imageUri, … })
+ * const img = await container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * Deployment({ image: img.imageUri, … });            // full URI
+ * // or chart values:  { repository: img.repository, tag: img.tag }
  * ```
  */
 export { buildContainer } from './build.js';
 export { ContainerBuildError } from './errors.js';
-export { container, type ContainerImage, type ContainerImageRef, type ContainerOptions, isContainerImageRef } from './image.js';
-export { hasContainerImageRefs, resolveContainerImages } from './resolve.js';
+export { type ContainerImage, type ContainerOptions, clearContainerCache, container, splitImageUri, } from './image.js';
 export type { ContainerBuildOptions, ContainerBuildResult, EcrRegistryConfig, OrbstackRegistryConfig, RegistryConfig, } from './registries/types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/core/containers/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/containers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,KAAK,cAAc,EAAE,KAAK,iBAAiB,EAAE,KAAK,gBAAgB,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAChI,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC;AAC7E,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,GACf,MAAM,uBAAuB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/core/containers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,mBAAmB,EACnB,SAAS,EACT,aAAa,GACd,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,sBAAsB,EACtB,cAAc,GACf,MAAM,uBAAuB,CAAC"}

package/dist/core/containers/index.js

@@ -5,24 +5,20 @@
  * Returns image URIs for use in TypeKro compositions.
  *
  * The low-level `buildContainer` builds + pushes imperatively and returns a URI. The higher-level
- * `container()` utility wraps it declaratively: define an image once at program scope and reference
- * its `.imageUri` from resources inside a composition — typekro builds it (via `buildContainer`) and
- * substitutes the literal URI at deploy time.
+ * `container()` is a memoized async builder that resolves to a SHAPED result (`{ imageUri,
+ * repository, tag }`) — `await` it in setup code, then feed the full URI to a resource's image field
+ * or the split `repository`/`tag` to a Helm chart's image values.
  *
  * @example
  * ```typescript
- * import { buildContainer, container } from 'typekro/containers';
+ * import { container } from 'typekro/containers';
  *
- * // Imperative (build now, get a URI):
- * const { imageUri } = await buildContainer({ context: './app', imageName: 'app', registry: { type: 'orbstack' } });
- *
- * // Declarative (defined outside a composition, referenced within):
- * const appImage = container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
- * // … later, inside a composition: Deployment({ image: appImage.imageUri, … })
+ * const img = await container({ context: './app', imageName: 'app', registry: { type: 'ecr' } });
+ * Deployment({ image: img.imageUri, … });            // full URI
+ * // or chart values:  { repository: img.repository, tag: img.tag }
  * ```
  */
 export { buildContainer } from './build.js';
 export { ContainerBuildError } from './errors.js';
-export { container, isContainerImageRef } from './image.js';
-export { hasContainerImageRefs, resolveContainerImages } from './resolve.js';
+export { clearContainerCache, container, splitImageUri, } from './image.js';
 //# sourceMappingURL=index.js.map

package/dist/core/containers/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/containers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAAE,SAAS,EAAsE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AAChI,OAAO,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/core/containers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,EAGL,mBAAmB,EACnB,SAAS,EACT,aAAa,GACd,MAAM,YAAY,CAAC"}

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

@@ -7,6 +7,7 @@
 import type { DeploymentClosure, DeploymentError, DeploymentResourceGraph, DeploymentResult, DirectResourceFactory, FactoryOptions, FactoryStatus, RollbackResult } from '../types/deployment.js';
 import type { Enhanced, KubernetesResource } from '../types/kubernetes.js';
 import type { KroCompatibleType, SchemaDefinition, StatusBuilder } from '../types/serialization.js';
+import type { AlchemyResourceDeclaration } from '../../alchemy/types.js';
 /**
  * DirectResourceFactory implementation
  *
@@ -17,13 +18,11 @@ export declare class DirectResourceFactoryImpl<TSpec extends KroCompatibleType,
     readonly mode: "direct";
     readonly name: string;
     readonly namespace: string;
-    readonly isAlchemyManaged: boolean;
     private readonly resources;
     private readonly closures;
     private readonly schemaDefinition;
     private readonly statusBuilder;
     private deploymentEngine;
-    private readonly alchemyScope;
     private readonly factoryOptions;
     private readonly singletonDefinitions;
     private readonly singletonOwnerStatuses;
@@ -156,6 +155,19 @@ export declare class DirectResourceFactoryImpl<TSpec extends KroCompatibleType,
      * Create a resource graph for a specific instance
      */
     createResourceGraphForInstance(spec: TSpec, instanceNameOverride?: string): DeploymentResourceGraph;
+    /**
+     * Emit this composition's resolved resources as declarative alchemy **v2** resources — one
+     * {@link AlchemyResourceDeclaration} per Kubernetes resource (matching the v1 integration's
+     * per-resource state granularity), topologically ordered with `dependsOn` wired from the
+     * composition's dependency graph. The v2 analog of the removed imperative direct-mode alchemy
+     * deploy. Instantiate them with `materializeAlchemyResources(KroResource, …)`, which turns
+     * `dependsOn` into alchemy `Output` edges so (a) each resource deploys only after the resources
+     * it references and (b) each reconcile resolves its cross-resource `KubernetesRef`s against those
+     * dependencies' live state before applying.
+     */
+    toAlchemyResources(spec: TSpec, opts?: {
+        instanceNameOverride?: string;
+    }): Promise<AlchemyResourceDeclaration[]>;
     /**
      * Resolve resources for a specific spec
      * This uses composition re-execution when available, or falls back to reference resolution