@intentius/chant-lexicon-k8s 0.1.0 → 0.1.5

package/src/composites/ray-job.ts

@@ -0,0 +1,235 @@
+/**
+ * RayJob composite — KubeRay RayJob CR + surrounding K8s infra.
+ *
+ * RayJob spins up an ephemeral Ray cluster, runs a single entrypoint command,
+ * then tears the cluster down. Ideal for batch training pipelines.
+ *
+ * Encodes the same production defaults as RayCluster (NetworkPolicy,
+ * preStop hooks, optional shared PVC, optional autoscaler RBAC).
+ */
+
+import { Composite, mergeDefaults } from "@intentius/chant";
+import {
+  ServiceAccount,
+  ClusterRole,
+  ClusterRoleBinding,
+  NetworkPolicy,
+  PersistentVolumeClaim,
+  RayJob as RayJobResource,
+} from "../generated";
+import {
+  type RayClusterSpec,
+  buildRayClusterParts,
+  buildRayNetworkPolicy,
+} from "./ray-cluster";
+
+export type { RayClusterSpec };
+export type { ResourceSpec, HeadGroupSpec, WorkerGroupSpec } from "./ray-cluster";
+
+export interface RayJobProps {
+  name: string;
+  namespace: string;
+  /**
+   * Entrypoint command to run on the Ray cluster.
+   * E.g. "python train.py --epochs 10"
+   */
+  entrypoint: string;
+  cluster: RayClusterSpec;
+  /**
+   * Ray runtime environment YAML string.
+   * Prefer pre-built images over pip installs here — each pip install adds
+   * startup latency per worker on cold start.
+   */
+  runtimeEnvYAML?: string;
+  /**
+   * Tear down the cluster after the job finishes (default: true).
+   * Set false to keep the cluster alive for debugging.
+   */
+  shutdownAfterJobFinishes?: boolean;
+  /**
+   * TTL in seconds before a finished RayJob is garbage-collected (default: 300).
+   */
+  ttlSecondsAfterFinished?: number;
+  sharedStorage?: {
+    storageClass: string;
+    size: string;
+    mountPath?: string;
+  };
+  enableAutoscaler?: boolean;
+  spilloverBucket?: string;
+  labels?: Record<string, string>;
+  defaults?: {
+    serviceAccount?: Partial<Record<string, unknown>>;
+    clusterRole?: Partial<Record<string, unknown>>;
+    clusterRoleBinding?: Partial<Record<string, unknown>>;
+    networkPolicy?: Partial<Record<string, unknown>>;
+    pvc?: Partial<Record<string, unknown>>;
+    rayJob?: Partial<Record<string, unknown>>;
+  };
+}
+
+export interface RayJobResult {
+  serviceAccount: InstanceType<typeof ServiceAccount>;
+  clusterRole?: InstanceType<typeof ClusterRole>;
+  clusterRoleBinding?: InstanceType<typeof ClusterRoleBinding>;
+  networkPolicy: InstanceType<typeof NetworkPolicy>;
+  pvc?: InstanceType<typeof PersistentVolumeClaim>;
+  rayJob: InstanceType<typeof RayJobResource>;
+}
+
+/**
+ * Create a RayJob composite — ephemeral Ray cluster for a single batch job.
+ *
+ * @example
+ * ```ts
+ * import { RayJob } from "@intentius/chant-lexicon-k8s";
+ *
+ * const job = RayJob({
+ *   name: "train-resnet",
+ *   namespace: "ray-system",
+ *   entrypoint: "python train.py --epochs 50",
+ *   cluster: {
+ *     image: "us-docker.pkg.dev/my-project/ray-images/ray:2.40.0",
+ *     head: { resources: { cpu: "2", memory: "8Gi" } },
+ *     workerGroups: [
+ *       { groupName: "gpu", replicas: 4,
+ *         resources: { cpu: "8", memory: "32Gi", gpu: 1 },
+ *         gpuTolerations: true },
+ *     ],
+ *   },
+ *   spilloverBucket: "my-ray-spill",
+ * });
+ * ```
+ */
+export const RayJob = Composite<RayJobProps>((props) => {
+  const {
+    name,
+    namespace,
+    entrypoint,
+    cluster,
+    runtimeEnvYAML,
+    shutdownAfterJobFinishes = true,
+    ttlSecondsAfterFinished = 300,
+    sharedStorage,
+    enableAutoscaler = false,
+    spilloverBucket,
+    labels: extraLabels = {},
+    defaults: defs,
+  } = props;
+
+  const saName = `${name}-head`;
+  const pvcName = sharedStorage ? `${name}-shared` : undefined;
+  const mountPath = sharedStorage?.mountPath;
+
+  const commonLabels: Record<string, string> = {
+    "app.kubernetes.io/name": name,
+    "app.kubernetes.io/managed-by": "chant",
+    "app.kubernetes.io/component": "ray",
+    ...extraLabels,
+  };
+
+  // -- ServiceAccount --
+
+  const serviceAccount = new ServiceAccount(mergeDefaults({
+    metadata: {
+      name: saName,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "service-account" },
+    },
+  }, defs?.serviceAccount));
+
+  // -- Autoscaler RBAC (optional) --
+
+  const clusterRole = enableAutoscaler ? new ClusterRole(mergeDefaults({
+    metadata: {
+      name: `${name}-autoscaler`,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "rbac" },
+    },
+    rules: [
+      {
+        apiGroups: [""],
+        resources: ["pods"],
+        verbs: ["get", "list", "watch", "create", "delete", "patch"],
+      },
+      {
+        apiGroups: [""],
+        resources: ["pods/status"],
+        verbs: ["get"],
+      },
+      {
+        apiGroups: ["ray.io"],
+        resources: ["rayjobs"],
+        verbs: ["get", "list", "patch"],
+      },
+    ],
+  }, defs?.clusterRole)) : undefined;
+
+  const clusterRoleBinding = enableAutoscaler ? new ClusterRoleBinding(mergeDefaults({
+    metadata: {
+      name: `${name}-autoscaler`,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "rbac" },
+    },
+    roleRef: {
+      apiGroup: "rbac.authorization.k8s.io",
+      kind: "ClusterRole",
+      name: `${name}-autoscaler`,
+    },
+    subjects: [{ kind: "ServiceAccount", name: saName, namespace }],
+  }, defs?.clusterRoleBinding)) : undefined;
+
+  // -- NetworkPolicy --
+
+  const networkPolicy = buildRayNetworkPolicy(
+    name, namespace, commonLabels, false, defs?.networkPolicy,
+  );
+
+  // -- Shared PVC (optional) --
+
+  const pvc = sharedStorage ? new PersistentVolumeClaim(mergeDefaults({
+    metadata: {
+      name: pvcName!,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "storage" },
+    },
+    spec: {
+      accessModes: ["ReadWriteMany"],
+      storageClassName: sharedStorage.storageClass,
+      resources: { requests: { storage: sharedStorage.size } },
+    },
+  }, defs?.pvc)) : undefined;
+
+  // -- RayJob CR --
+
+  const { headGroupSpec, workerGroupSpecs, rayVersion } = buildRayClusterParts(
+    cluster, saName, spilloverBucket, pvcName, mountPath,
+  );
+
+  const rayJob = new RayJobResource(mergeDefaults({
+    metadata: {
+      name,
+      namespace,
+      labels: commonLabels,
+    },
+    spec: {
+      entrypoint,
+      ...(runtimeEnvYAML && { runtimeEnvYAML }),
+      shutdownAfterJobFinishes,
+      ttlSecondsAfterFinished,
+      rayClusterSpec: {
+        ...(rayVersion && { rayVersion }),
+        ...(enableAutoscaler && { enableInTreeAutoscaling: true }),
+        headGroupSpec,
+        workerGroupSpecs,
+      },
+    },
+  }, defs?.rayJob));
+
+  return {
+    serviceAccount,
+    ...(clusterRole && { clusterRole }),
+    ...(clusterRoleBinding && { clusterRoleBinding }),
+    networkPolicy,
+    ...(pvc && { pvc }),
+    rayJob,
+  };
+}, "RayJob");

package/src/composites/ray-service.ts

@@ -0,0 +1,271 @@
+/**
+ * RayService composite — KubeRay RayService CR + surrounding K8s infra.
+ *
+ * RayService manages a persistent Ray Serve HTTP endpoint with zero-downtime
+ * blue-green upgrades. Ideal for online inference and serving workloads.
+ *
+ * Encodes the same production defaults as RayCluster (NetworkPolicy, preStop
+ * hooks, PDB, optional shared PVC, optional autoscaler RBAC) plus a
+ * LoadBalancer Service exposing the Serve HTTP endpoint on port 8000.
+ */
+
+import { Composite, mergeDefaults } from "@intentius/chant";
+import {
+  ServiceAccount,
+  ClusterRole,
+  ClusterRoleBinding,
+  NetworkPolicy,
+  PodDisruptionBudget,
+  PersistentVolumeClaim,
+  Service,
+  RayService as RayServiceResource,
+} from "../generated";
+import {
+  type RayClusterSpec,
+  buildRayClusterParts,
+  buildRayNetworkPolicy,
+} from "./ray-cluster";
+
+export type { RayClusterSpec };
+export type { ResourceSpec, HeadGroupSpec, WorkerGroupSpec } from "./ray-cluster";
+
+export interface RayServiceProps {
+  name: string;
+  namespace: string;
+  /**
+   * Ray Serve application config in YAML format.
+   * Passed verbatim to spec.serveConfigV2.
+   * See https://docs.ray.io/en/latest/serve/production-guide/config.html
+   */
+  serveConfigV2: string;
+  cluster: RayClusterSpec;
+  sharedStorage?: {
+    storageClass: string;
+    size: string;
+    mountPath?: string;
+  };
+  enableAutoscaler?: boolean;
+  spilloverBucket?: string;
+  labels?: Record<string, string>;
+  defaults?: {
+    serviceAccount?: Partial<Record<string, unknown>>;
+    clusterRole?: Partial<Record<string, unknown>>;
+    clusterRoleBinding?: Partial<Record<string, unknown>>;
+    networkPolicy?: Partial<Record<string, unknown>>;
+    pdb?: Partial<Record<string, unknown>>;
+    pvc?: Partial<Record<string, unknown>>;
+    serveService?: Partial<Record<string, unknown>>;
+    rayService?: Partial<Record<string, unknown>>;
+  };
+}
+
+export interface RayServiceResult {
+  serviceAccount: InstanceType<typeof ServiceAccount>;
+  clusterRole?: InstanceType<typeof ClusterRole>;
+  clusterRoleBinding?: InstanceType<typeof ClusterRoleBinding>;
+  networkPolicy: InstanceType<typeof NetworkPolicy>;
+  pdb: InstanceType<typeof PodDisruptionBudget>;
+  pvc?: InstanceType<typeof PersistentVolumeClaim>;
+  /** LoadBalancer Service exposing Ray Serve on port 8000. */
+  serveService: InstanceType<typeof Service>;
+  rayService: InstanceType<typeof RayServiceResource>;
+}
+
+/**
+ * Create a RayService composite — persistent Ray Serve endpoint with
+ * zero-downtime blue-green upgrades.
+ *
+ * @example
+ * ```ts
+ * import { RayService } from "@intentius/chant-lexicon-k8s";
+ *
+ * const svc = RayService({
+ *   name: "inference",
+ *   namespace: "ray-system",
+ *   serveConfigV2: `
+ *     applications:
+ *       - name: classifier
+ *         import_path: app:deployment
+ *         deployments:
+ *           - name: Classifier
+ *             num_replicas: 2
+ *   `,
+ *   cluster: {
+ *     image: "us-docker.pkg.dev/my-project/ray-images/ray:2.40.0",
+ *     head: { resources: { cpu: "2", memory: "8Gi" } },
+ *     workerGroups: [
+ *       { groupName: "gpu", replicas: 2,
+ *         resources: { cpu: "4", memory: "16Gi", gpu: 1 },
+ *         gpuTolerations: true },
+ *     ],
+ *   },
+ * });
+ * ```
+ */
+export const RayService = Composite<RayServiceProps>((props) => {
+  const {
+    name,
+    namespace,
+    serveConfigV2,
+    cluster,
+    sharedStorage,
+    enableAutoscaler = false,
+    spilloverBucket,
+    labels: extraLabels = {},
+    defaults: defs,
+  } = props;
+
+  const saName = `${name}-head`;
+  const pvcName = sharedStorage ? `${name}-shared` : undefined;
+  const mountPath = sharedStorage?.mountPath;
+
+  const commonLabels: Record<string, string> = {
+    "app.kubernetes.io/name": name,
+    "app.kubernetes.io/managed-by": "chant",
+    "app.kubernetes.io/component": "ray",
+    ...extraLabels,
+  };
+
+  // -- ServiceAccount --
+
+  const serviceAccount = new ServiceAccount(mergeDefaults({
+    metadata: {
+      name: saName,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "service-account" },
+    },
+  }, defs?.serviceAccount));
+
+  // -- Autoscaler RBAC (optional) --
+
+  const clusterRole = enableAutoscaler ? new ClusterRole(mergeDefaults({
+    metadata: {
+      name: `${name}-autoscaler`,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "rbac" },
+    },
+    rules: [
+      {
+        apiGroups: [""],
+        resources: ["pods"],
+        verbs: ["get", "list", "watch", "create", "delete", "patch"],
+      },
+      {
+        apiGroups: [""],
+        resources: ["pods/status"],
+        verbs: ["get"],
+      },
+      {
+        apiGroups: ["ray.io"],
+        resources: ["rayservices"],
+        verbs: ["get", "list", "patch"],
+      },
+    ],
+  }, defs?.clusterRole)) : undefined;
+
+  const clusterRoleBinding = enableAutoscaler ? new ClusterRoleBinding(mergeDefaults({
+    metadata: {
+      name: `${name}-autoscaler`,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "rbac" },
+    },
+    roleRef: {
+      apiGroup: "rbac.authorization.k8s.io",
+      kind: "ClusterRole",
+      name: `${name}-autoscaler`,
+    },
+    subjects: [{ kind: "ServiceAccount", name: saName, namespace }],
+  }, defs?.clusterRoleBinding)) : undefined;
+
+  // -- NetworkPolicy --
+  // RayService exposes port 8000 (Serve HTTP) externally via LoadBalancer,
+  // so we allow ingress from outside the cluster on that port.
+
+  const networkPolicy = buildRayNetworkPolicy(
+    name, namespace, commonLabels, false, defs?.networkPolicy,
+  );
+
+  // -- PodDisruptionBudget (head) --
+
+  const pdb = new PodDisruptionBudget(mergeDefaults({
+    metadata: {
+      name: `${name}-head`,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "disruption-budget" },
+    },
+    spec: {
+      minAvailable: 1,
+      selector: {
+        matchLabels: {
+          "ray.io/cluster-name": name,
+          "ray.io/node-type": "head",
+        },
+      },
+    },
+  }, defs?.pdb));
+
+  // -- Shared PVC (optional) --
+
+  const pvc = sharedStorage ? new PersistentVolumeClaim(mergeDefaults({
+    metadata: {
+      name: pvcName!,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "storage" },
+    },
+    spec: {
+      accessModes: ["ReadWriteMany"],
+      storageClassName: sharedStorage.storageClass,
+      resources: { requests: { storage: sharedStorage.size } },
+    },
+  }, defs?.pvc)) : undefined;
+
+  // -- Ray Serve LoadBalancer Service --
+
+  const serveService = new Service(mergeDefaults({
+    metadata: {
+      name: `${name}-serve`,
+      namespace,
+      labels: { ...commonLabels, "app.kubernetes.io/component": "serve" },
+    },
+    spec: {
+      type: "LoadBalancer",
+      selector: {
+        "ray.io/cluster-name": name,
+        "ray.io/node-type": "head",
+      },
+      ports: [{ port: 8000, targetPort: 8000, protocol: "TCP", name: "serve" }],
+    },
+  }, defs?.serveService));
+
+  // -- RayService CR --
+
+  const { headGroupSpec, workerGroupSpecs, rayVersion } = buildRayClusterParts(
+    cluster, saName, spilloverBucket, pvcName, mountPath,
+  );
+
+  const rayService = new RayServiceResource(mergeDefaults({
+    metadata: {
+      name,
+      namespace,
+      labels: commonLabels,
+    },
+    spec: {
+      serveConfigV2,
+      rayClusterConfig: {
+        ...(rayVersion && { rayVersion }),
+        ...(enableAutoscaler && { enableInTreeAutoscaling: true }),
+        headGroupSpec,
+        workerGroupSpecs,
+      },
+    },
+  }, defs?.rayService));
+
+  return {
+    serviceAccount,
+    ...(clusterRole && { clusterRole }),
+    ...(clusterRoleBinding && { clusterRoleBinding }),
+    networkPolicy,
+    pdb,
+    ...(pvc && { pvc }),
+    serveService,
+    rayService,
+  };
+}, "RayService");

package/src/coverage.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { existsSync } from "fs";
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";

package/src/crd/crd-sources.ts

@@ -0,0 +1,29 @@
+/**
+ * Third-party CRD sources included in k8s lexicon generation.
+ *
+ * Add entries here to have CRDs fetched and code-generated alongside
+ * the core Kubernetes OpenAPI types. The CRD YAML is fetched at
+ * generation time (npm run generate) and baked into the output.
+ */
+
+import type { CRDSource } from "./types";
+
+/**
+ * KubeRay operator CRDs — ray.io/v1
+ *
+ * Produces:
+ *   K8s::Ray::RayCluster  → apiVersion: ray.io/v1, kind: RayCluster
+ *   K8s::Ray::RayJob      → apiVersion: ray.io/v1, kind: RayJob
+ *   K8s::Ray::RayService  → apiVersion: ray.io/v1, kind: RayService
+ *
+ * Operator install: kubectl apply -f
+ *   https://github.com/ray-project/kuberay/releases/download/v1.3.0/kuberay-operator.yaml
+ */
+const KUBERAY_VERSION = "v1.3.0";
+const KUBERAY_CRD_BASE = `https://raw.githubusercontent.com/ray-project/kuberay/${KUBERAY_VERSION}/helm-chart/kuberay-operator/crds`;
+
+export const CRD_SOURCES: CRDSource[] = [
+  { type: "url", url: `${KUBERAY_CRD_BASE}/ray.io_rayclusters.yaml` },
+  { type: "url", url: `${KUBERAY_CRD_BASE}/ray.io_rayjobs.yaml` },
+  { type: "url", url: `${KUBERAY_CRD_BASE}/ray.io_rayservices.yaml` },
+];

package/src/crd/loader.ts

@@ -5,6 +5,7 @@
  * live cluster introspection via kubectl.
  */
 
+import { existsSync, readFileSync } from "fs";
 import type { CRDSource, CRDSpec } from "./types";
 import type { K8sParseResult } from "../spec/parse";
 import { parseCRD } from "./parser";
@@ -53,13 +54,11 @@ async function loadFromFile(source: CRDSource): Promise<string> {
     throw new Error("CRD source type 'file' requires a 'path' property");
   }
 
-  const file = Bun.file(source.path);
-  const exists = await file.exists();
-  if (!exists) {
+  if (!existsSync(source.path)) {
     throw new Error(`CRD file not found: ${source.path}`);
   }
 
-  return file.text();
+  return readFileSync(source.path, "utf8");
 }
 
 /**
@@ -85,28 +84,21 @@ async function loadFromURL(source: CRDSource): Promise<string> {
  * requires kubectl access and proper authentication.
  */
 async function loadFromCluster(source: CRDSource): Promise<string> {
-  const contextArg = source.context ? `--context=${source.context}` : "";
-  const nsArg = source.namespace ? `--namespace=${source.namespace}` : "";
+  const { execFile } = await import("child_process");
+  const { promisify } = await import("util");
+  const execFileAsync = promisify(execFile);
 
-  const args = ["kubectl", "get", "crds", "-o", "yaml"];
-  if (contextArg) args.push(contextArg);
-  if (nsArg) args.push(nsArg);
+  const args = ["get", "crds", "-o", "yaml"];
+  if (source.context) args.push(`--context=${source.context}`);
+  if (source.namespace) args.push(`--namespace=${source.namespace}`);
 
-  const proc = Bun.spawn(args, {
-    stdout: "pipe",
-    stderr: "pipe",
-  });
-
-  const stdout = await new Response(proc.stdout).text();
-  const stderr = await new Response(proc.stderr).text();
-  const exitCode = await proc.exited;
-
-  if (exitCode !== 0) {
+  const { stdout, stderr } = await execFileAsync("kubectl", args).catch((err: NodeJS.ErrnoException & { stdout?: string; stderr?: string }) => {
     throw new Error(
-      `kubectl failed (exit ${exitCode}): ${stderr.trim() || "unknown error"}. ` +
+      `kubectl failed: ${err.stderr?.trim() || err.message}. ` +
       "Ensure kubectl is installed and configured with access to the target cluster.",
     );
-  }
+  });
 
+  void stderr;
   return stdout;
 }

package/src/crd/parser.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { parseCRD, parseCRDSpec } from "./parser";
 
 describe("parseCRD", () => {

package/src/crd/parser.ts

@@ -10,7 +10,7 @@
 import type { K8sParseResult, ParsedProperty, ParsedPropertyType, GroupVersionKind } from "../spec/parse";
 import type { CRDSpec } from "./types";
 import type { PropertyConstraints } from "@intentius/chant/codegen/json-schema";
-import { parseYAML } from "@intentius/chant/yaml";
+import { loadAll } from "js-yaml";
 
 /**
  * Normalize a CRD group to a PascalCase namespace segment.
@@ -34,17 +34,17 @@ function normalizeGroupName(group: string): string {
 export function parseCRD(content: string): K8sParseResult[] {
   const results: K8sParseResult[] = [];
 
-  // Support multi-document YAML for CRD bundles
-  const documents = content
-    .split(/^---\s*$/m)
-    .map((d) => d.trim())
-    .filter((d) => d.length > 0);
+  // Use js-yaml to handle full YAML spec (CRD YAMLs use same-indent arrays,
+  // nested block scalars, and deep nesting not supported by the lightweight parser).
+  const documents: unknown[] = [];
+  loadAll(content, (doc) => documents.push(doc));
 
-  for (const docStr of documents) {
-    const doc = parseYAML(docStr) as Record<string, unknown>;
-    if (!doc || doc.kind !== "CustomResourceDefinition") continue;
+  for (const doc of documents) {
+    if (!doc || typeof doc !== "object") continue;
+    const docObj = doc as Record<string, unknown>;
+    if (docObj.kind !== "CustomResourceDefinition") continue;
 
-    const spec = doc.spec as CRDSpec | undefined;
+    const spec = docObj.spec as CRDSpec | undefined;
     if (!spec?.group || !spec?.names?.kind || !spec?.versions) continue;
 
     const crdResults = parseCRDSpec(spec);
@@ -160,10 +160,15 @@ function extractPropertyTypes(schema: OpenAPISchema, parentTypeName: string): Pa
   const specSchema = schema.properties?.spec;
   if (!specSchema?.properties) return results;
 
+  // Use the short name (last :: segment) as prefix so the naming pipeline
+  // produces valid TS identifiers: "RayCluster_AutoscalerOptions" not
+  // "K8s::Ray::RayCluster::AutoscalerOptions".
+  const shortName = parentTypeName.split("::").pop()!;
+
   for (const [name, prop] of Object.entries(specSchema.properties)) {
     // Extract inline object definitions as property types
     if (prop.type === "object" && prop.properties) {
-      const ptName = `${parentTypeName}::${pascalCase(name)}`;
+      const ptName = `${shortName}_${pascalCase(name)}`;
       const requiredSet = new Set<string>(prop.required ?? []);
 
       results.push({
@@ -184,7 +189,7 @@ function extractPropertyTypes(schema: OpenAPISchema, parentTypeName: string): Pa
     if (prop.type === "array" && prop.items?.type === "object" && prop.items.properties) {
       const itemSchema = prop.items;
       const itemProps = itemSchema.properties!;
-      const ptName = `${parentTypeName}::${pascalCase(singularize(name))}`;
+      const ptName = `${shortName}_${pascalCase(singularize(name))}`;
       const requiredSet = new Set<string>(itemSchema.required ?? []);
 
       results.push({

package/src/default-labels.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import {
   defaultLabels,
   defaultAnnotations,