k8ts 0.4.19 → 0.4.20

package/src/file/exports.ts

@@ -1,6 +1,6 @@
-import { FutureExports, Producer } from "@k8ts/instruments"
+import { FutureExports, LiveRefable, Producer } from "@k8ts/instruments"
 import { seq, type Seq } from "doddle"
-import type { ManifestResource } from "../node"
+import { ManifestResource } from "../node"
 import { k8ts_namespace } from "../runner/exporter/meta"
 import { Factory } from "./factory"
 import type { FileOrigin } from "./origin"
@@ -12,7 +12,7 @@ export namespace FileExports {
     > = Producer.Producer<Factory.FromScope<Scope>, Produced>
     export interface Props<
         Scope extends FileOrigin.Scope = FileOrigin.Scope,
-        Produced extends ManifestResource = ManifestResource
+        Produced extends LiveRefable = LiveRefable
     > {
         origin: FileOrigin<Scope>
         FILE: Producer<Scope, Produced>
@@ -20,7 +20,7 @@ export namespace FileExports {
 
     export class Core {
         #props: Props
-        #produced: Seq<ManifestResource>
+        #produced: Seq<LiveRefable>
         constructor(props: Props) {
             this.#props = props
             const producer = Producer.map(props.FILE, () => {
@@ -31,6 +31,7 @@ export namespace FileExports {
                 }
             })
             this.#produced = seq(() => producer(props.origin))
+                .as<ManifestResource>()
                 .each(x => {
                     x.meta.add(k8ts_namespace, {
                         "#is-exported": "true"
@@ -52,7 +53,7 @@ export namespace FileExports {
         }
     }
 
-    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+    export function make<Scope extends FileOrigin.Scope, Produced extends LiveRefable>(
         props: Props<Scope, Produced>
     ): Core & FutureExports<Produced> {
         const core = new Core(props as any)

package/src/file/factory.ts

@@ -87,7 +87,7 @@ export namespace Factory {
             props: Service.Props<DeployPorts, ExposedPorts>
         ) {
             return new Service.Service(this.origin, this._metaWithName(name), props) as LiveRefable<
-                Service<DeployPorts, ExposedPorts>,
+                Service<ExposedPorts>,
                 Name
             >
         }

package/src/file/file.ts

@@ -1,9 +1,8 @@
-import type { FutureExports, Origin } from "@k8ts/instruments"
-import type { ManifestResource } from "../node"
+import type { FutureExports, LiveRefable, Origin } from "@k8ts/instruments"
 import { FileExports as Exports_ } from "./exports"
 import { Factory as Factory_ } from "./factory"
 import { FileOrigin } from "./origin"
-export type File<T extends ManifestResource = ManifestResource> = File.File<T>
+export type File<T extends LiveRefable = LiveRefable> = File.File<T>
 export namespace File {
     export import Factory = Factory_
 
@@ -11,15 +10,15 @@ export namespace File {
 
     export interface Props<
         Scope extends FileOrigin.Scope = FileOrigin.Scope,
-        Produced extends ManifestResource = ManifestResource
+        Produced extends LiveRefable = LiveRefable
     > extends FileOrigin.Props<Scope> {
         FILE: Exports.Producer<Scope, Produced>
     }
 
-    export type Input = Exports.Core & Iterable<ManifestResource>
-    export type File<T extends ManifestResource> = Exports.Core & FutureExports<T>
+    export type Input = Exports.Core & Iterable<LiveRefable>
+    export type File<T extends LiveRefable> = Exports.Core & FutureExports<T>
 
-    export function make<Scope extends FileOrigin.Scope, Produced extends ManifestResource>(
+    export function make<Scope extends FileOrigin.Scope, Produced extends LiveRefable>(
         name: string,
         props: Props<Scope, Produced>,
         parent: Origin

package/src/file/origin.ts

@@ -1,11 +1,11 @@
-import { BaseOriginEntity, Origin, OriginEntityProps } from "@k8ts/instruments"
+import { BaseOriginEntity, Origin, OriginEntityProps, Refable } from "@k8ts/instruments"
 import { Meta } from "@k8ts/metadata"
 import { k8tsBuildKind } from "../k8ts-sys-kind"
-import type { Namespace } from "../resources"
+import { api } from "../kinds"
 export type FileOrigin<FScope extends FileOrigin.Scope = FileOrigin.Scope> =
     FileOrigin.FileEntity<FScope>
 export namespace FileOrigin {
-    export type Scope = Namespace | "cluster"
+    export type Scope = Refable<api.v1_.Namespace> | "cluster"
 
     export interface SmallerProps extends OriginEntityProps {
         meta?: Meta.Input

package/src/kind-map.ts

@@ -2,8 +2,8 @@ import {
     BaseOriginEntity,
     Kind,
     kinded,
-    MetadataEntity,
-    OriginEntityProps
+    OriginEntityProps,
+    ResourceEntity
 } from "@k8ts/instruments"
 import { k8tsBuildKind } from "./k8ts-sys-kind"
 const ident = k8tsBuildKind.kind("World")
@@ -23,7 +23,9 @@ class K8tsRootOriginEntity extends BaseOriginEntity<OriginEntityProps> {
     }
 
     get decorator() {
-        return <Target extends new (...args: any[]) => MetadataEntity>(kind: Kind.Identifier) => {
+        return <Target extends abstract new (...args: any[]) => ResourceEntity>(
+            kind: Kind.Identifier
+        ) => {
             return (ctor: Target) => {
                 this.node.resourceKinds.add(kind, ctor)
                 kinded(kind)(ctor)
@@ -37,3 +39,4 @@ export const K8tsRootOrigin = new K8tsRootOriginEntity()
 export const K8tsResources = K8tsRootOrigin.node.resourceKinds
 
 export const k8ts = K8tsRootOrigin.decorator
+export const REF_TYPE = Symbol.for("k8ts:ref")

package/src/kinds.ts

@@ -0,0 +1,127 @@
+import { Kind } from "@k8ts/instruments"
+export namespace api {
+    export const v1 = Kind.version("v1")
+    export type v1 = typeof v1
+
+    export namespace v1_ {
+        export function kind_<Name extends string>(name: Name): Kind<Name, typeof v1> {
+            return v1.kind(name)
+        }
+
+        export const ConfigMap = v1.kind("ConfigMap")
+        export type ConfigMap = typeof ConfigMap
+
+        export const Secret = v1.kind("Secret")
+        export type Secret = typeof Secret
+
+        export const Service = v1.kind("Service")
+        export type Service = typeof Service
+
+        export const Pod = v1.kind("Pod")
+        export type Pod = typeof Pod
+
+        export namespace Pod_ {
+            export const Container = Pod.subkind("Container")
+            export type Container = typeof Container
+
+            export const Port = Container.subkind("Port")
+            export type Port = typeof Port
+
+            export const EnvVar = Container.subkind("EnvVar")
+            export type EnvVar = typeof EnvVar
+
+            export const VolumeMount = Container.subkind("VolumeMount")
+            export type VolumeMount = typeof VolumeMount
+
+            export const DeviceMount = Container.subkind("DeviceMount")
+            export type DeviceMount = typeof DeviceMount
+
+            export const Volume = Pod.subkind("Volume")
+            export type Volume = typeof Volume
+
+            export const Device = Volume.subkind("Device")
+            export type Device = typeof Device
+        }
+
+        export const Node = v1.kind("Node")
+        export type Node = typeof Node
+
+        export const Namespace = v1.kind("Namespace")
+        export type Namespace = typeof Namespace
+
+        export const ServiceAccount = v1.kind("ServiceAccount")
+        export type ServiceAccount = typeof ServiceAccount
+
+        export const PersistentVolume = v1.kind("PersistentVolume")
+        export type PersistentVolume = typeof PersistentVolume
+
+        export const PersistentVolumeClaim = v1.kind("PersistentVolumeClaim")
+        export type PersistentVolumeClaim = typeof PersistentVolumeClaim
+
+        export const PodTemplate = v1.kind("PodTemplate")
+        export type PodTemplate = typeof PodTemplate
+    }
+
+    export const apps = Kind.group("apps")
+    export type apps = typeof apps
+
+    export namespace apps_ {
+        export const v1 = apps.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const Deployment = v1.kind("Deployment")
+            export type Deployment = typeof Deployment
+
+            export const StatefulSet = v1.kind("StatefulSet")
+            export type StatefulSet = typeof StatefulSet
+
+            export const DaemonSet = v1.kind("DaemonSet")
+            export type DaemonSet = typeof DaemonSet
+
+            export const ReplicaSet = v1.kind("ReplicaSet")
+            export type ReplicaSet = typeof ReplicaSet
+
+            export const ControllerRevision = v1.kind("ControllerRevision")
+            export type ControllerRevision = typeof ControllerRevision
+        }
+    }
+
+    export const networking = Kind.group("networking.k8s.io")
+    export type networking = typeof networking
+
+    export namespace networking_ {
+        export const v1 = networking.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const NetworkPolicy = v1.kind("NetworkPolicy")
+            export type NetworkPolicy = typeof NetworkPolicy
+        }
+    }
+
+    export const gateway = Kind.group("gateway.networking.k8s.io")
+    export type gateway = typeof gateway
+
+    export namespace gateway_ {
+        export const v1 = gateway.version("v1")
+        export type v1 = typeof v1
+
+        export namespace v1_ {
+            export const Gateway = v1.kind("Gateway")
+            export type Gateway = typeof Gateway
+
+            export const GatewayClass = v1.kind("GatewayClass")
+            export type GatewayClass = typeof GatewayClass
+
+            export const HttpRoute = v1.kind("HTTPRoute")
+            export type HttpRoute = typeof HttpRoute
+
+            export const TcpRoute = v1.kind("TCPRoute")
+            export type TcpRoute = typeof TcpRoute
+
+            export const TlsRoute = v1.kind("TLSRoute")
+            export type TlsRoute = typeof TlsRoute
+        }
+    }
+}

package/src/node/abs-resource.ts

@@ -1,14 +1,15 @@
-import { displayers, Kind, Origin, RefKey, ResourceNode } from "@k8ts/instruments"
+import { displayers, Kind, Origin, RefKey, ResourceEntity, ResourceNode } from "@k8ts/instruments"
 import { Doddle, doddle } from "doddle"
-export interface DependsOn {
-    resource: AbsResource
-    text: string
+
+export interface ResourceIdentBlock {
+    kind: Kind.IdentParent
+    name: string
 }
 @displayers({
     simple: s => s.node,
     pretty: s => s.node
 })
-export abstract class AbsResource<Props extends object = object> {
+export abstract class AbsResource<Props extends object = object> implements ResourceEntity {
     abstract readonly kind: Kind.Identifier<string, Kind.Identifier>
 
     private _node: Doddle<ResourceNode>
@@ -16,7 +17,7 @@ export abstract class AbsResource<Props extends object = object> {
     get node() {
         return this._node.pull()
     }
-    constructor(
+    protected constructor(
         origin: Origin,
         readonly name: string,
         readonly props: Props

package/src/node/equiv-cdk8s.ts

@@ -1,15 +1,14 @@
-import { Embedder } from "@k8ts/instruments"
+import { Embedder, Kinded, LiveRefable } from "@k8ts/instruments"
 import { Construct } from "constructs"
-import { ManifestResource } from "./manifest-resource"
 
 export type Cdk8sCtor = {
     new (parent: Construct, id: string, props: any): Construct
 }
-export type ManifestResourceCtor = new (...args: any[]) => ManifestResource
-export const EquivCdk8s = new Embedder<ManifestResource, Cdk8sCtor>("CDK8S_RESOURCE")
+export type KindedCtor = new (...args: any[]) => Kinded
+export const EquivCdk8s = new Embedder<LiveRefable, Cdk8sCtor>("CDK8S_RESOURCE")
 
 export function equiv_cdk8s(ctor: Cdk8sCtor) {
-    return <F extends ManifestResourceCtor>(target: F) => {
+    return <F extends KindedCtor>(target: F) => {
         const cdk8s = EquivCdk8s.tryGet(target.prototype)
         if (cdk8s) {
             throw new Error(`Target ${target} already has a cdk8s equivalent! ${cdk8s}`)

package/src/node/manifest-resource.ts

@@ -1,7 +1,11 @@
 import { Builder, Kind, type Origin } from "@k8ts/instruments"
 import type { Meta, MutableMeta } from "@k8ts/metadata"
+import { ResourceIdentBlock } from "./abs-resource"
 import { TopResource } from "./top-resource"
 
+export interface ManifestResourceIdent extends ResourceIdentBlock {
+    name: string
+}
 export abstract class ManifestResource<Props extends object = object> extends TopResource<Props> {
     protected async manifest() {
         return Builder.get(this).manifest()

package/src/node/sub-resource.ts

@@ -7,14 +7,14 @@ import type { ManifestResource } from "./manifest-resource"
 })
 export abstract class SubResource<Props extends object = object> extends AbsResource<Props> {
     constructor(
-        readonly parent: ManifestResource,
+        readonly parent: SubResource | ManifestResource,
         name: string,
         props: Props
     ) {
         super(parent.node.origin, name, props)
     }
 
-    get namespace() {
+    get namespace(): string | undefined {
         return this.parent.namespace
     }
 }

package/src/resources/configmap/configmap.ts

@@ -8,8 +8,8 @@ import {
     resolveText
 } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 export type ConfigMap = ConfigMap.ConfigMap
@@ -20,8 +20,7 @@ export namespace ConfigMap {
         binaryData?: DataSourceRecord_Binary
     }
 
-    const ident = v1.kind("ConfigMap")
-    @k8ts(ident)
+    @k8ts(api.v1_.ConfigMap)
     @relations("none")
     @equiv_cdk8s(CDK.KubeConfigMap)
     @manifest({
@@ -37,6 +36,6 @@ export namespace ConfigMap {
         }
     })
     export class ConfigMap extends ManifestResource<Props> {
-        override kind = ident
+        override kind = api.v1_.ConfigMap
     }
 }

package/src/resources/deployment/deployment.ts

@@ -1,9 +1,9 @@
-import { manifest, Origin, relations } from "@k8ts/instruments"
+import { manifest, Origin, Refable, relations } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
 import { omit } from "lodash"
 import { CDK } from "../../_imports"
-import { apps_v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 import { PodTemplate } from "../pod/pod-template"
@@ -14,9 +14,10 @@ export namespace Deployment {
     export type Props<Ports extends string> = SmallerProps & {
         template: PodTemplate.Props<Ports>
     }
-
-    const ident = apps_v1.kind("Deployment")
-    @k8ts(ident)
+    export type AbsDeployment<Ports extends string> = Refable<api.apps_.v1_.Deployment> & {
+        __PORTS__: Ports
+    }
+    @k8ts(api.apps_.v1_.Deployment)
     @equiv_cdk8s(CDK.KubeDeployment)
     @relations({
         kids: s => [s.template]
@@ -39,8 +40,10 @@ export namespace Deployment {
         }
     })
     export class Deployment<Ports extends string = string> extends ManifestResource<Props<Ports>> {
-        kind = ident
+        __PORTS__!: Ports
+        kind = api.apps_.v1_.Deployment
         template: PodTemplate<Ports>
+
         constructor(origin: Origin, meta: Meta | MutableMeta, props: Props<Ports>) {
             super(origin, meta, props)
             this.template = new PodTemplate.PodTemplate(

package/src/resources/http-route/http-route.ts

@@ -1,8 +1,8 @@
 import { manifest, relations } from "@k8ts/instruments"
 import { CDK } from "../../_imports"
-import { gateway_v1 } from "../../api-versions"
 import type { External } from "../../external"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { ManifestResource } from "../../node"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import type { Service } from "../service"
@@ -10,15 +10,13 @@ import type { Service } from "../service"
 export type HttpRoute<Ports extends string> = HttpRoute.HttpRoute<Ports>
 
 export namespace HttpRoute {
-    const gwKind = gateway_v1.kind("Gateway")
     export interface Props<Ports extends string> {
-        gateway: External<typeof gwKind>
+        gateway: External<api.gateway_.v1_.Gateway>
         hostname: string
         backend: Service.Port<Ports>
     }
 
-    const kind = gateway_v1.kind("HTTPRoute")
-    @k8ts(kind)
+    @k8ts(api.gateway_.v1_.HttpRoute)
     @relations({
         needs: self => ({
             gateway: self.props.gateway,
@@ -42,6 +40,6 @@ export namespace HttpRoute {
         }
     })
     export class HttpRoute<Ports extends string> extends ManifestResource<Props<Ports>> {
-        kind = gateway_v1.kind("HTTPRoute")
+        kind = api.gateway_.v1_.HttpRoute
     }
 }

package/src/resources/namespace/namespace.ts

@@ -1,15 +1,14 @@
 import { manifest, relations, type Origin } from "@k8ts/instruments"
 import { Meta, MutableMeta } from "@k8ts/metadata"
 import { CDK } from "../../_imports"
-import { v1 } from "../../api-versions"
 import { k8ts } from "../../kind-map"
+import { api } from "../../kinds"
 import { equiv_cdk8s } from "../../node/equiv-cdk8s"
 import { ManifestResource } from "../../node/manifest-resource"
 export type Namespace = Namespace.Namespace
 export namespace Namespace {
     export interface Props {}
-    const ident = v1.kind("Namespace")
-    @k8ts(ident)
+    @k8ts(api.v1_.Namespace)
     @relations("none")
     @equiv_cdk8s(CDK.KubeNamespace)
     @manifest({
@@ -20,7 +19,7 @@ export namespace Namespace {
         }
     })
     export class Namespace extends ManifestResource<Props> {
-        override kind = ident
+        override kind = api.v1_.Namespace
         constructor(origin: Origin, meta: Meta | MutableMeta, props?: Props) {
             super(origin, meta.toMutable(), props ?? {})
         }

package/src/resources/persistent/claim/pvc.ts

@@ -1,7 +1,7 @@
 import { manifest, relations, ResourcesSpec, Unit } from "@k8ts/instruments"
 import { CDK } from "../../../_imports"
-import { v1 } from "../../../api-versions"
 import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import { ManifestResource } from "../../../node"
 import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { Access } from "../access-mode"
@@ -18,15 +18,14 @@ export namespace Pvc {
     export interface Props<Mode extends DataMode> extends PvcResources {
         accessModes: Access
         mode?: Mode
-        bind: Pv<Mode>
+        bind: Pv.AbsPv<Mode>
     }
 
-    const ident = v1.kind("PersistentVolumeClaim")
-    @k8ts(ident)
+    @k8ts(api.v1_.PersistentVolumeClaim)
     @equiv_cdk8s(CDK.KubePersistentVolumeClaim)
     @relations({
         needs: self => ({
-            bind: self.props.bind
+            bind: self.bound
         })
     })
     @manifest({
@@ -49,6 +48,10 @@ export namespace Pvc {
         }
     })
     export class Pvc<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        kind = ident
+        kind = api.v1_.PersistentVolumeClaim
+
+        get bound() {
+            return this.props.bind as Pv<Mode>
+        }
     }
 }

package/src/resources/persistent/volume/pv.ts

@@ -1,8 +1,8 @@
-import { manifest, relations, type Unit } from "@k8ts/instruments"
+import { manifest, Refable, relations, type Unit } from "@k8ts/instruments"
 import { CDK } from "../../../_imports"
-import { v1 } from "../../../api-versions"
 import { MakeError } from "../../../error"
 import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import { equiv_cdk8s } from "../../../node/equiv-cdk8s"
 import { ManifestResource } from "../../../node/manifest-resource"
 import { Access } from "../access-mode"
@@ -23,9 +23,9 @@ export namespace Pv {
         nodeAffinity?: CDK.VolumeNodeAffinity
     }
     export type Reclaim = "Retain" | "Delete" | "Recycle"
-
-    const ident = v1.kind("PersistentVolume")
-
+    export type AbsPv<Mode extends DataMode = DataMode> = Refable<api.v1_.PersistentVolume> & {
+        __MODE__: Mode
+    }
     @equiv_cdk8s(CDK.KubePersistentVolume)
     @manifest({
         body(self) {
@@ -59,9 +59,10 @@ export namespace Pv {
             }
         }
     })
-    @k8ts(ident)
+    @k8ts(api.v1_.PersistentVolume)
     @relations("none")
     export class Pv<Mode extends DataMode = DataMode> extends ManifestResource<Props<Mode>> {
-        declare readonly kind: typeof ident
+        __MODE__!: Mode
+        readonly kind = api.v1_.PersistentVolume
     }
 }

package/src/resources/pod/container/container.ts

@@ -1,5 +1,6 @@
 import {
     Env,
+    Kinded,
     PortSet,
     relations,
     ResourcesSpec,
@@ -15,10 +16,12 @@ import { toContainerPorts, toEnvVars } from "../../utils/adapters"
 
 import { seq } from "doddle"
 import { mapKeys, mapValues } from "lodash"
+import { k8ts } from "../../../kind-map"
+import { api } from "../../../kinds"
 import type { ManifestResource } from "../../../node"
 import { SubResource } from "../../../node/sub-resource"
 import { Mount as Mount_ } from "./mounts"
-export type Container<Ports extends string> = Container.Container<Ports>
+export type Container<Ports extends string = string> = Container.Container<Ports>
 export namespace Container {
     export import Mount = Mount_
     const container_ResourcesSpec = ResourcesSpec.make({
@@ -27,10 +30,11 @@ export namespace Container {
     })
 
     type Resources = (typeof container_ResourcesSpec)["__INPUT__"]
+    type SomeMount = Kinded<api.v1_.Pod_.DeviceMount | api.v1_.Pod_.VolumeMount>
     export type Mounts = {
-        [key: string]: Mount.ContainerDeviceMount | Mount.ContainerVolumeMount
+        [key: string]: SomeMount
     }
-    export interface Props<Ports extends string = never> {
+    export interface K8tsProps<Ports extends string = never> {
         image: TaggedImage
         ports?: InputPortSetRecord<Ports>
         command?: CmdBuilder
@@ -39,19 +43,22 @@ export namespace Container {
         securityContext?: CDK.SecurityContext
         resources?: Resources
     }
+    export type Props<Ports extends string = never> = K8tsProps<Ports> &
+        Omit<CDK.Container, keyof K8tsProps | "name">
+
+    @k8ts(api.v1_.Pod_.Container)
     @relations({
         needs: self => {
             const a = self.mounts
             return mapValues(
                 mapKeys(a, x => x.path),
-                x => x.mount.parent
+                x => x.mount.volume
             )
         }
     })
-    export class Container<Ports extends string> extends SubResource<Props<Ports>> {
-        get kind() {
-            return this.parent.kind.subkind("Container")
-        }
+    export class Container<Ports extends string = string> extends SubResource<Props<Ports>> {
+        __PORTS__!: Ports
+        readonly kind = api.v1_.Pod_.Container
 
         get mounts() {
             return Map(this.props.mounts ?? {})
@@ -59,7 +66,7 @@ export namespace Container {
                     return [
                         mount,
                         {
-                            mount,
+                            mount: mount as Mount.ContainerVolumeMount | Mount.ContainerDeviceMount,
                             path: path as string
                         }
                     ]
@@ -69,7 +76,7 @@ export namespace Container {
         }
 
         get volumes() {
-            return seq(this.mounts.map(x => x.mount.parent))
+            return seq(this.mounts.map(x => x.mount.volume))
                 .uniq()
                 .toArray()
                 .pull()
@@ -96,7 +103,7 @@ export namespace Container {
             parent: ManifestResource,
             name: string,
             readonly subtype: "init" | "main",
-            override readonly props: Props<Ports>
+            override readonly props: K8tsProps<Ports>
         ) {
             super(parent, name, props)
         }
@@ -106,7 +113,8 @@ export namespace Container {
                 volumeMounts: [],
                 volumeDevices: []
             } as Pick<CDK.Container, "volumeMounts" | "volumeDevices">
-            for (const [path, mount] of Object.entries(this.props.mounts ?? {})) {
+            for (const mnt of this.mounts) {
+                const { mount, path } = mnt
                 if (mount instanceof Mount.ContainerDeviceMount) {
                     x.volumeDevices!.push(mount.submanifest(path))
                 } else {