@intentius/chant-lexicon-helm 0.1.4 → 0.1.9

package/dist/integrity.json

@@ -1,38 +1,38 @@
 {
-  "algorithm": "xxhash64",
+  "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "63a0898ec956a5de",
-    "meta.json": "b7aab243e162dfaf",
-    "types/index.d.ts": "e8011da51963f058",
-    "rules/values-no-helm-tpl.ts": "ed23236546936fd0",
-    "rules/chart-metadata.ts": "d0cff2b78fed78d3",
-    "rules/values-no-secrets.ts": "213276bfe1fb8ff7",
-    "rules/no-hardcoded-image.ts": "c75aa9c33016c3b9",
-    "rules/whm301.ts": "f3ed3a269093527",
-    "rules/whm104.ts": "e2d644da2a9dc605",
-    "rules/whm005-no-empty-wrapper.ts": "1a1baea985f0bd86",
-    "rules/whm103.ts": "a777a13f2eaf1831",
-    "rules/whm406.ts": "c76ac5a44c3e9dcd",
-    "rules/whm405.ts": "ec82442f9120e5e0",
-    "rules/whm105.ts": "8977ec834713b90c",
-    "rules/whm403.ts": "729d10edb48b0d03",
-    "rules/whm203.ts": "2bb546d268c84232",
-    "rules/whm407.ts": "f1fbc6942aff8e96",
-    "rules/whm502.ts": "2c9901ecbfaf92cb",
-    "rules/whm404.ts": "8847425e930d41c1",
-    "rules/whm402.ts": "f722014a723654af",
-    "rules/whm302.ts": "44e58ce621ae6d1a",
-    "rules/whm501.ts": "e9a9f2b4e034a51f",
-    "rules/helm-helpers.ts": "2e0cc249268227ed",
-    "rules/whm101.ts": "533ae8f65cb2227b",
-    "rules/whm102.ts": "4c0c494c253df56a",
-    "rules/whm401.ts": "fe72c3c450a12f93",
-    "rules/whm201.ts": "f263fe69901552eb",
-    "rules/whm202.ts": "dbe1cbb3237be84f",
-    "rules/whm204.ts": "7b57de71795fc102",
-    "skills/chant-helm.md": "6476c552b9235085",
-    "skills/chant-helm-patterns.md": "cc9bfe5595f22710",
-    "skills/chant-helm-security.md": "a7b950513dac7d37"
+    "manifest.json": "9a813a15786c5b5691cfc1ad544f2a2ba1148c0ef7a13a66ca72aeaf9b94a87b",
+    "meta.json": "14243c5730a07c6a6edc35ddd351438547d58df5cf345f2233a355b0c7611ccc",
+    "types/index.d.ts": "5377696ca8698cd2999e4680feb8e8e4b54a7b49fb603a87b2f27356114d1794",
+    "rules/chart-metadata.ts": "8f3377e893d5e2828460b7fe5924fca098334245a9a2fdb90f6b67e490eaf091",
+    "rules/no-hardcoded-image.ts": "b00433bd5f4e963ffd56d8a623c00fbfaa40dc37b6d72609d26c91a309d75a90",
+    "rules/values-no-helm-tpl.ts": "bd30478da004bafaed6ed6231636f1e2867f5255deb6313c8f6e3505c5c91b11",
+    "rules/values-no-secrets.ts": "ec9193fb39764e65e44022e39fda124147350e4d2b4e2e34deaa5db82116f76c",
+    "rules/helm-helpers.ts": "c2631bbf261573c553e475cfc2f1b007fc5feb4b1f986b5ba660f3290f4d3eaf",
+    "rules/whm005-no-empty-wrapper.ts": "bfecf05449106c639b317eecdcd969ad2a851c4be9ee029380f99278e2a19630",
+    "rules/whm101.ts": "6fb49f184cec898640118a3ce14edc5d62c05c694491b0eab4e53dbc10921e8d",
+    "rules/whm102.ts": "99ea2a695b49fe39e20b8dccdec5bcf5b189e08ac026318ce633fbf9a226132d",
+    "rules/whm103.ts": "80f533af6d9bae924a3cc3ceedf158f13d4138d6ef3115a0e3093f5a0464592d",
+    "rules/whm104.ts": "1752338ade55c87dafee23dc09e0150c4ae55ac90eb8b8e9010c89b7ad73503d",
+    "rules/whm105.ts": "d710b04267c558839ec99001e0b4604017ef6484e7083585fe160192a5920d69",
+    "rules/whm201.ts": "0de1a8cad242feadbb4e9c4e0eebfb94df1f2c2bf535802ebf535067f7859619",
+    "rules/whm202.ts": "6a2fc424d8b753113cd13de565ce93dfd1cdf0e606c56977b9e17e92147abf54",
+    "rules/whm203.ts": "d98176fd2a2c0d6ddc2d3b37180c5e7be618b47b6c12821df9b51cfe7950d938",
+    "rules/whm204.ts": "b5e37aea05662e16e02843e20e4642de82b666026d58e1ebf18c337768fdaff8",
+    "rules/whm301.ts": "0ed09a07a8f3d59fb3c2bc330e7b92f7c2eb31655b6a301b06b10b485fe12edc",
+    "rules/whm302.ts": "d4cb8cdf776e4bdf0551fc8ab28c584f66efbe6648aef0b325acb07e415da73b",
+    "rules/whm401.ts": "a49b41ff9837f2c9ada011d4ee31fffe8e68b278d50badbab32459ea05bc4a01",
+    "rules/whm402.ts": "917f85fbc4d31c9b7eec5eda684aa24b847d33bd6f0507bdc435c1796bd66476",
+    "rules/whm403.ts": "716cc86eb1a4ba345ef875ac50cef033d017edf50964695ec9399b593d3bcce2",
+    "rules/whm404.ts": "e4c7d6877fb3f658ce3a109722fa65b508d7160e186fdf5a63d8ddfc6262e218",
+    "rules/whm405.ts": "6d7d230b94e694c3b94dd8fbfe719856c1fbf171ef6dd0552843f56f6c512c03",
+    "rules/whm406.ts": "79ce3b318ce53ee74bbf814ae31e0873fe882096dcb5c5369495bed022dbf57d",
+    "rules/whm407.ts": "200190f5de2d86d2bcc5aee0b5ce4807919ec727b1fc14576ea17b9b3073838b",
+    "rules/whm501.ts": "e6afa7c0eface9820380bf189fe8be58f4a6997dd5b74f76335022650616d080",
+    "rules/whm502.ts": "c3ed7b4b5215d96e46eba758aca2171928d8f8fb1eb20452ea6b4393672755b0",
+    "skills/chant-helm.md": "94528606c7a972f478d3c716eb7fe5fd79a6520532ccc4f9a3c99e9b0d691025",
+    "skills/chant-helm-patterns.md": "9e79e6a46391da46709d8aa57e2825a7cd9eb981cd923f02ad60836c49b2561e",
+    "skills/chant-helm-security.md": "bfc367eabceed2e84f1cf94501b407df78aeed963cec104f24a321d0962063c9"
   },
-  "composite": "3af38f2aed6c80fd"
+  "composite": "50e28442c88c8b3fddc2f5c33e9a5ddca3fd44e129c2147d500d91b9f45de1b5"
 }

package/dist/manifest.json

@@ -1,6 +1,6 @@
 {
   "name": "helm",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "chantVersion": ">=0.1.0",
   "namespace": "Helm",
   "intrinsics": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intentius/chant-lexicon-helm",
-  "version": "0.1.4",
+  "version": "0.1.9",
   "description": "Helm chart lexicon for chant — declarative IaC in TypeScript",
   "license": "Apache-2.0",
   "homepage": "https://intentius.io/chant",
@@ -36,17 +36,17 @@
     "./types": "./dist/types/index.d.ts"
   },
   "scripts": {
-    "generate": "bun run src/codegen/generate-cli.ts",
-    "bundle": "bun run src/package-cli.ts",
-    "validate": "bun run src/validate-cli.ts",
-    "docs": "bun run src/codegen/docs-cli.ts",
-    "prepack": "bun run generate && bun run bundle && bun run validate"
+    "generate": "tsx src/codegen/generate-cli.ts",
+    "bundle": "tsx src/package-cli.ts",
+    "validate": "tsx src/validate-cli.ts",
+    "docs": "tsx src/codegen/docs-cli.ts",
+    "prepack": "npm run generate && npm run bundle && npm run validate"
   },
   "dependencies": {
-    "@intentius/chant-lexicon-k8s": "0.1.4"
+    "@intentius/chant-lexicon-k8s": "*"
   },
   "devDependencies": {
-    "@intentius/chant": "0.1.4",
+    "@intentius/chant": "*",
     "typescript": "^5.9.3"
   },
   "peerDependencies": {

package/src/codegen/docs-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 import { generateDocs } from "./docs";
 
 await generateDocs({ verbose: true });

package/src/codegen/docs.test.ts

@@ -1,9 +1,9 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 
 describe("Helm docs generation", () => {
   test("docs module is importable", async () => {
     const mod = await import("./docs");
-    expect(mod.generateDocs).toBeFunction();
+    expect(typeof mod.generateDocs).toBe("function");
   });
 
   test("generateDocs function signature accepts options", async () => {

package/src/codegen/docs.ts

@@ -479,6 +479,6 @@ When you scaffold a new project with \`chant init --lexicon helm\`, the skill is
   writeDocsSite(config, result);
 
   if (opts?.verbose) {
-    console.error(`Generated ${result.pages.length} documentation pages`);
+    console.error(`Generated ${result.pages.size} documentation pages`);
   }
 }

package/src/codegen/generate-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
  * CLI entry point for Helm lexicon generation.
  */

package/src/codegen/generate.test.ts

@@ -1,11 +1,11 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { generate } from "./generate";
 
 describe("Helm generate pipeline", () => {
   test("generate module is importable", async () => {
     const mod = await import("./generate");
-    expect(mod.generate).toBeFunction();
-    expect(mod.writeGeneratedFiles).toBeFunction();
+    expect(typeof mod.generate).toBe("function");
+    expect(typeof mod.writeGeneratedFiles).toBe("function");
   });
 
   test("generates lexicon JSON, types, and index", async () => {

package/src/codegen/package.test.ts

@@ -1,10 +1,10 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { packageLexicon } from "./package";
 
 describe("Helm package pipeline", () => {
   test("packageLexicon is importable", async () => {
     const mod = await import("./package");
-    expect(mod.packageLexicon).toBeFunction();
+    expect(typeof mod.packageLexicon).toBe("function");
   });
 
   test("packageLexicon returns a valid result", async () => {

package/src/codegen/package.ts

@@ -3,11 +3,10 @@
  * with Helm-specific manifest building and skill collection.
  */
 
-import { createRequire } from "module";
 import { readFileSync } from "fs";
-const require = createRequire(import.meta.url);
 import { join, dirname } from "path";
 import { fileURLToPath } from "url";
+import { helmPlugin } from "../plugin";
 import {
   packagePipeline,
   collectSkills,
@@ -52,7 +51,6 @@ export async function packageLexicon(opts: PackageOptions = {}): Promise<Package
       srcDir: pkgDir,
 
       collectSkills: () => {
-        const { helmPlugin } = require("../plugin");
         const skillDefs = helmPlugin.skills?.() ?? [];
         return collectSkills(skillDefs);
       },

package/src/composites/composites.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
 import { HelmWebApp } from "./helm-web-app";
 import { HelmStatefulService } from "./helm-stateful-service";

package/src/composites/helm-monitored-service.ts

@@ -228,7 +228,7 @@ export const HelmMonitoredService = Composite<HelmMonitoredServiceProps>((props)
           interval: values.monitoring.scrapeInterval,
         }],
       },
-    }) as Record<string, unknown>,
+    }) as unknown as Record<string, unknown>,
     defs?.serviceMonitor,
   ));
 
@@ -267,7 +267,7 @@ export const HelmMonitoredService = Composite<HelmMonitoredServiceProps>((props)
             rules: toYaml(values.alerting.rules),
           }],
         },
-      }) as Record<string, unknown>,
+      }) as unknown as Record<string, unknown>,
       defs?.prometheusRule,
     ));
   }

package/src/composites/helm-namespace-env.ts

@@ -134,7 +134,7 @@ export const HelmNamespaceEnv = Composite<HelmNamespaceEnvProps>((props) => {
         spec: {
           hard: toYaml(values.resourceQuota.hard),
         },
-      }) as Record<string, unknown>,
+      }) as unknown as Record<string, unknown>,
       defs?.resourceQuota,
     ));
   }
@@ -155,7 +155,7 @@ export const HelmNamespaceEnv = Composite<HelmNamespaceEnvProps>((props) => {
             defaultRequest: toYaml(values.limitRange.defaultRequest),
           }],
         },
-      }) as Record<string, unknown>,
+      }) as unknown as Record<string, unknown>,
       defs?.limitRange,
     ));
   }
@@ -173,7 +173,7 @@ export const HelmNamespaceEnv = Composite<HelmNamespaceEnvProps>((props) => {
           podSelector: {},
           policyTypes: ["Ingress", "Egress"],
         },
-      }) as Record<string, unknown>,
+      }) as unknown as Record<string, unknown>,
       defs?.networkPolicy,
     ));
   }

package/src/composites/helm-secure-ingress.ts

@@ -96,7 +96,7 @@ export const HelmSecureIngress = Composite<HelmSecureIngressProps>((props) => {
           },
         }),
       },
-    }) as Record<string, unknown>,
+    }) as unknown as Record<string, unknown>,
     defs?.ingress,
   ));
 
@@ -117,7 +117,7 @@ export const HelmSecureIngress = Composite<HelmSecureIngressProps>((props) => {
         },
         dnsNames: values.ingress.hosts,
       },
-    }) as Record<string, unknown>,
+    }) as unknown as Record<string, unknown>,
     defs?.certificate,
   ));
 

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/helpers.test.ts

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

package/src/import/import.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { stripTemplateExpressions, classifyExpression } from "./template-stripper";
 import { HelmParser } from "./parser";
 import { HelmGenerator } from "./generator";

package/src/import/roundtrip.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { HelmParser } from "./parser";
 import { HelmGenerator } from "./generator";
 

package/src/index.ts

@@ -7,6 +7,10 @@ export { helmPlugin } from "./plugin";
 // Resources
 export { Chart, Values, ValuesOverride, HelmTest, HelmNotes, HelmHook, HelmDependency, HelmMaintainer, HelmCRD } from "./resources";
 
+// HelmRender — render an upstream chart at chant build time
+export { HelmRender } from "./render";
+export type { HelmRenderProps } from "./render";
+
 // Intrinsics
 export {
   HelmTpl,

package/src/intrinsics.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { INTRINSIC_MARKER } from "@intentius/chant/intrinsic";
 import {
   HelmTpl,

package/src/intrinsics.ts

@@ -308,7 +308,9 @@ export function quote(val: HelmTpl): HelmTpl {
  * `printf("%s:%s", values.image.repository, values.image.tag)`
  * → `{{ printf "%s:%s" .Values.image.repository .Values.image.tag }}`
  */
-export function printf(fmt: string, ...args: HelmTpl[]): HelmTpl {
+export function printf(fmt: string, ...args: (HelmTpl | string)[]): HelmTpl {
+  // extractExpr already accepts both HelmTpl and string; widening here is
+  // purely additive (existing callers passing HelmTpl[] keep working).
   const argExprs = args.map(extractExpr).join(" ");
   return new HelmTpl(`{{ printf "${fmt}" ${argExprs} }}`);
 }

package/src/lint/post-synth/post-synth.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext, PostSynthDiagnostic } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm101 } from "./whm101";

package/src/lint/post-synth/whm101.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm101 } from "./whm101";

package/src/lint/post-synth/whm102.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm102 } from "./whm102";

package/src/lint/post-synth/whm103.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm103 } from "./whm103";

package/src/lint/post-synth/whm104.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm104 } from "./whm104";

package/src/lint/post-synth/whm105.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm105 } from "./whm105";

package/src/lint/post-synth/whm201.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm201 } from "./whm201";

package/src/lint/post-synth/whm202.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm202 } from "./whm202";

package/src/lint/post-synth/whm203.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm203 } from "./whm203";

package/src/lint/post-synth/whm204.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm204 } from "./whm204";

package/src/lint/post-synth/whm301.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm301 } from "./whm301";

package/src/lint/post-synth/whm302.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm302 } from "./whm302";

package/src/lint/post-synth/whm401.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm401 } from "./whm401";

package/src/lint/post-synth/whm402.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm402 } from "./whm402";

package/src/lint/post-synth/whm403.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm403 } from "./whm403";

package/src/lint/post-synth/whm404.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm404 } from "./whm404";

package/src/lint/post-synth/whm405.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm405 } from "./whm405";

package/src/lint/post-synth/whm406.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm406 } from "./whm406";

package/src/lint/post-synth/whm407.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm407 } from "./whm407";

package/src/lint/post-synth/whm501.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm501 } from "./whm501";

package/src/lint/post-synth/whm502.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import type { PostSynthContext } from "@intentius/chant/lint/post-synth";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { whm502 } from "./whm502";

package/src/lint/rules/chart-metadata.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import type { LintContext } from "@intentius/chant/lint/rule";
 import { chartMetadataRule } from "./chart-metadata";

package/src/lint/rules/lint-rules.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import type { LintContext } from "@intentius/chant/lint/rule";
 import { chartMetadataRule } from "./chart-metadata";

package/src/lint/rules/no-hardcoded-image.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import type { LintContext } from "@intentius/chant/lint/rule";
 import { noHardcodedImageRule } from "./no-hardcoded-image";

package/src/lint/rules/values-no-secrets.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import * as ts from "typescript";
 import type { LintContext } from "@intentius/chant/lint/rule";
 import { valuesNoSecretsRule } from "./values-no-secrets";

package/src/list-artifacts.test.ts

@@ -0,0 +1,94 @@
+import { describe, test, expect, vi, beforeEach } from "vitest";
+
+const execMock = vi.fn();
+vi.mock("node:child_process", async () => {
+  const actual = await vi.importActual<typeof import("node:child_process")>("node:child_process");
+  return { ...actual, exec: (cmd: string, cb: (err: Error | null, out: { stdout: string; stderr: string }) => void) => {
+    Promise.resolve(execMock(cmd)).then(
+      (out) => cb(null, out),
+      (err) => cb(err as Error, { stdout: "", stderr: "" }),
+    );
+  } };
+});
+
+const { listArtifacts } = await import("./list-artifacts");
+
+describe("helm listArtifacts", () => {
+  beforeEach(() => {
+    execMock.mockReset();
+  });
+
+  test("queries `helm list -A -o json` and maps releases to artifacts", async () => {
+    let receivedCmd = "";
+    execMock.mockImplementation((cmd: string) => {
+      receivedCmd = cmd;
+      return {
+        stdout: JSON.stringify([
+          {
+            name: "web", namespace: "default", revision: "1",
+            updated: "2026-05-09 10:00:00.000000 +0000 UTC",
+            status: "deployed", chart: "web-1.0.0", app_version: "1.0",
+          },
+          {
+            name: "redis", namespace: "infra", revision: "3",
+            updated: "2026-05-09 09:00:00.000000 +0000 UTC",
+            status: "deployed", chart: "redis-7.4.0", app_version: "7.4",
+          },
+        ]),
+        stderr: "",
+      };
+    });
+
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+
+    expect(receivedCmd).toBe("helm list -A -o json");
+    expect(Object.keys(result).sort()).toEqual(["release/default/web", "release/infra/redis"]);
+    expect(result["release/default/web"]).toEqual({
+      type: "Helm::Release",
+      physicalId: "default/web",
+      status: "deployed",
+      lastUpdated: "2026-05-09 10:00:00.000000 +0000 UTC",
+      attributes: { chart: "web-1.0.0", revision: "1", appVersion: "1.0", namespace: "default" },
+    });
+  });
+
+  test("helm binary not installed → returns {} cleanly", async () => {
+    execMock.mockImplementation(() => { throw new Error("helm: command not found"); });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result).toEqual({});
+  });
+
+  test("empty cluster (no releases) → returns {}", async () => {
+    execMock.mockResolvedValue({ stdout: "[]", stderr: "" });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result).toEqual({});
+  });
+
+  test("status mapping for non-deployed states surfaces correctly", async () => {
+    execMock.mockResolvedValue({
+      stdout: JSON.stringify([
+        { name: "broken", namespace: "default", revision: "2", status: "failed", chart: "x-1.0", app_version: "1" },
+      ]),
+      stderr: "",
+    });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result["release/default/broken"].status).toBe("failed");
+  });
+
+  test("revision attribute changes between releases (drift signal)", async () => {
+    execMock.mockResolvedValue({
+      stdout: JSON.stringify([
+        { name: "web", namespace: "default", revision: "5", status: "deployed", chart: "web-2.0.0", app_version: "2.0" },
+      ]),
+      stderr: "",
+    });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result["release/default/web"].attributes).toMatchObject({ revision: "5", chart: "web-2.0.0" });
+  });
+
+  test("malformed JSON output → returns {} (don't fail the snapshot)", async () => {
+    execMock.mockResolvedValue({ stdout: "not json", stderr: "" });
+    const result = await listArtifacts({ environment: "prod", entities: new Map() });
+    expect(result).toEqual({});
+  });
+});

package/src/list-artifacts.ts

@@ -0,0 +1,79 @@
+/**
+ * Live introspection of Helm releases via `helm list -A -o json`.
+ *
+ * The Helm lexicon's chant entities describe chart-authoring primitives
+ * (Chart.yaml, templates/, values.yaml). The runtime concept — a Helm
+ * release installed in a kubeconfig context — is created by `helm install`
+ * outside chant's entity model. This implementation reports those releases
+ * as artifacts so `state diff --live` / `WatchOp` can detect manual
+ * installs/upgrades/rollbacks that slip past CI.
+ *
+ * Helm-not-installed (binary missing) → returns `{}` cleanly so other
+ * lexicons' snapshots aren't blocked.
+ */
+
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+import type { ArtifactMetadata } from "@intentius/chant/lexicon";
+
+const execAsync = promisify(exec);
+
+interface HelmListEntry {
+  name?: string;
+  namespace?: string;
+  revision?: string;
+  updated?: string;
+  status?: string;
+  chart?: string;
+  app_version?: string;
+}
+
+function pruneUndefined<T extends Record<string, unknown>>(obj: T): Record<string, unknown> {
+  const out: Record<string, unknown> = {};
+  for (const [k, v] of Object.entries(obj)) {
+    if (v !== undefined) out[k] = v;
+  }
+  return out;
+}
+
+export async function listArtifacts(_options: {
+  environment: string;
+  entities: Map<string, { entityType: string; props: Record<string, unknown> }>;
+}): Promise<Record<string, ArtifactMetadata>> {
+  const result: Record<string, ArtifactMetadata> = {};
+
+  let stdout: string;
+  try {
+    ({ stdout } = await execAsync("helm list -A -o json"));
+  } catch {
+    // Binary not installed, no kubeconfig, or some other error — return
+    // empty rather than blocking the whole snapshot.
+    return result;
+  }
+
+  let entries: HelmListEntry[];
+  try {
+    entries = JSON.parse(stdout);
+  } catch {
+    return result;
+  }
+
+  for (const entry of entries) {
+    if (!entry.name || !entry.namespace) continue;
+    const key = `release/${entry.namespace}/${entry.name}`;
+    result[key] = {
+      type: "Helm::Release",
+      physicalId: `${entry.namespace}/${entry.name}`,
+      status: entry.status ?? "unknown",
+      lastUpdated: entry.updated,
+      attributes: pruneUndefined({
+        chart: entry.chart,
+        revision: entry.revision,
+        appVersion: entry.app_version,
+        namespace: entry.namespace,
+      }),
+    };
+  }
+
+  return result;
+}

package/src/lsp/completions.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/lsp/hover.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/package-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
  * CLI entry point for Helm lexicon packaging.
  */

package/src/plugin.test.ts

@@ -1,4 +1,4 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { helmPlugin } from "./plugin";
 import { isLexiconPlugin } from "@intentius/chant/lexicon";
 

package/src/plugin.ts

@@ -65,13 +65,13 @@ export const helmPlugin: LexiconPlugin = {
   },
 
   mcpTools() {
-    return [createDiffTool(helmSerializer, "Compare current Helm chart build output against previous output")];
+    return [createDiffTool(helmSerializer, "Compare current Helm chart build output against previous output", "helm")];
   },
 
   mcpResources() {
     return [
       {
-        uri: "resource-catalog",
+        uri: "helm:resource-catalog",
         name: "Helm Chart Resource Catalog",
         description: "JSON list of all supported Helm chart resource types",
         mimeType: "application/json",
@@ -374,4 +374,9 @@ export const service = new Service({
 
     console.error(`Packaged ${stats.resources} resources, ${stats.ruleCount} rules, ${stats.skillCount} skills`);
   },
+
+  async listArtifacts(options) {
+    const { listArtifacts } = await import("./list-artifacts");
+    return listArtifacts(options);
+  },
 };

package/src/render.test.ts

@@ -0,0 +1,173 @@
+import { describe, test, expect, beforeAll } from "vitest";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+
+import { HelmRender } from "./render";
+
+const FIXTURE_DIR = join(tmpdir(), "chant-helm-render-fixture");
+const CHART_DIR = join(FIXTURE_DIR, "tiny-chart");
+const REPO_DIR = join(FIXTURE_DIR, "repo");
+
+/**
+ * Builds a tiny self-contained chart that emits one Deployment + one
+ * Service, packages it as a local chart repo, and serves it via file://.
+ * Avoids network access in tests.
+ */
+function maybeSetupFixture(): boolean {
+  // If helm isn't on PATH, the test will be skipped at the call site.
+  try {
+    execFileSync("helm", ["version"], { stdio: "ignore" });
+  } catch {
+    return false;
+  }
+
+  if (existsSync(FIXTURE_DIR)) {
+    rmSync(FIXTURE_DIR, { recursive: true, force: true });
+  }
+  mkdirSync(join(CHART_DIR, "templates"), { recursive: true });
+  mkdirSync(REPO_DIR, { recursive: true });
+
+  writeFileSync(
+    join(CHART_DIR, "Chart.yaml"),
+    `apiVersion: v2
+name: tiny-chart
+description: Minimal chart for chant-lexicon-helm HelmRender tests
+type: application
+version: 0.1.0
+appVersion: "1.0"
+`,
+  );
+
+  writeFileSync(
+    join(CHART_DIR, "values.yaml"),
+    `replicaCount: 1
+image:
+  repository: nginx
+  tag: "latest"
+service:
+  port: 80
+`,
+  );
+
+  writeFileSync(
+    join(CHART_DIR, "templates", "deployment.yaml"),
+    `apiVersion: apps/v1
+kind: Deployment
+metadata:
+  name: {{ .Release.Name }}-tiny
+spec:
+  replicas: {{ .Values.replicaCount }}
+  selector:
+    matchLabels:
+      app: {{ .Release.Name }}
+  template:
+    metadata:
+      labels:
+        app: {{ .Release.Name }}
+    spec:
+      containers:
+      - name: app
+        image: "{{ .Values.image.repository }}:{{ .Values.image.tag }}"
+`,
+  );
+
+  writeFileSync(
+    join(CHART_DIR, "templates", "service.yaml"),
+    `apiVersion: v1
+kind: Service
+metadata:
+  name: {{ .Release.Name }}-tiny
+spec:
+  selector:
+    app: {{ .Release.Name }}
+  ports:
+  - port: {{ .Values.service.port }}
+`,
+  );
+
+  // Package the chart into a .tgz and create a repo index.yaml.
+  execFileSync("helm", ["package", CHART_DIR, "-d", REPO_DIR], { stdio: "ignore" });
+  execFileSync("helm", ["repo", "index", REPO_DIR], { stdio: "ignore" });
+  return true;
+}
+
+const fixtureAvailable = maybeSetupFixture();
+
+describe.skipIf(!fixtureAvailable)("HelmRender", () => {
+  beforeAll(() => {
+    // Ensure fixture is fresh for the suite.
+    expect(fixtureAvailable).toBe(true);
+  });
+
+  test("renders a local chart into K8s declarables (Deployment + Service)", () => {
+    const result = HelmRender({
+      name: "rel",
+      chart: CHART_DIR,
+      noCache: true,
+    });
+
+    // Composite returns its members under .members; iterate keys.
+    const members = result.members as Record<string, unknown>;
+    const keys = Object.keys(members);
+    expect(keys.length).toBeGreaterThanOrEqual(2);
+    const deployment = keys.find((k) => k.startsWith("Deployment_"));
+    const service = keys.find((k) => k.startsWith("Service_"));
+    expect(deployment).toBeDefined();
+    expect(service).toBeDefined();
+  });
+
+  test("createNamespace adds a Namespace declarable", () => {
+    const result = HelmRender({
+      name: "rel",
+      chart: CHART_DIR,
+      namespace: "myns",
+      createNamespace: true,
+      noCache: true,
+    });
+    const keys = Object.keys(result.members as Record<string, unknown>);
+    expect(keys).toContain("__namespace");
+  });
+
+  test("values overrides are applied (replicaCount: 3)", () => {
+    const result = HelmRender({
+      name: "rel",
+      chart: CHART_DIR,
+      values: { replicaCount: 3 },
+      noCache: true,
+    });
+    const members = result.members as Record<string, unknown>;
+    const deploymentKey = Object.keys(members).find((k) => k.startsWith("Deployment_"));
+    expect(deploymentKey).toBeDefined();
+    const dep = members[deploymentKey!] as {
+      props: { spec: { replicas: number } };
+    };
+    expect(dep.props.spec.replicas).toBe(3);
+  });
+
+  test("cache reuse: second render with same args skips helm CLI", () => {
+    // First, render with cache enabled.
+    const first = HelmRender({
+      name: "rel",
+      chart: CHART_DIR,
+    });
+    expect(Object.keys(first.members as Record<string, unknown>).length).toBeGreaterThanOrEqual(2);
+
+    // Now sabotage `helm` by pointing PATH at an empty dir — if cache is used,
+    // the second call should still succeed.
+    const emptyDir = join(tmpdir(), "chant-helm-render-empty-path");
+    if (!existsSync(emptyDir)) mkdirSync(emptyDir);
+    const origPath = process.env.PATH;
+    process.env.PATH = emptyDir;
+    try {
+      const second = HelmRender({
+        name: "rel",
+        chart: CHART_DIR,
+      });
+      expect(Object.keys(second.members as Record<string, unknown>).length).toBeGreaterThanOrEqual(2);
+    } finally {
+      process.env.PATH = origPath;
+    }
+  });
+});

package/src/render.ts

@@ -0,0 +1,195 @@
+/**
+ * HelmRender — render an upstream Helm chart at chant build time.
+ *
+ * Most chant projects that want to install third-party operators (ESO,
+ * cert-manager, ingress-nginx, etc.) ran `helm template` or `helm install`
+ * as a separate deploy phase. That meant the chant build output was
+ * incomplete — `kubectl apply -f dist/...yaml` didn't carry those operators.
+ *
+ * `HelmRender({ repo, chart, version, values })` resolves at synth time:
+ *   1. Shells out to `helm template` (requires the `helm` binary in PATH).
+ *   2. Parses the resulting multi-document YAML.
+ *   3. Emits each rendered K8s manifest as a Declarable in the build output.
+ *   4. Caches the rendered output under `~/.chant/helm-renders/<hash>/`
+ *      keyed by (repo, chart, version, values) so subsequent builds skip
+ *      network access.
+ *
+ * The lexicon must include both `helm` and `k8s` (since rendered manifests
+ * are k8s resources).
+ *
+ * @example
+ * import { HelmRender } from "@intentius/chant-lexicon-helm";
+ *
+ * export const eso = HelmRender({
+ *   name: "external-secrets",
+ *   repo: "https://charts.external-secrets.io",
+ *   chart: "external-secrets",
+ *   version: "0.10.4",
+ *   namespace: "external-secrets",
+ *   createNamespace: true,
+ *   values: { installCRDs: true },
+ * });
+ */
+
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { Composite } from "@intentius/chant";
+import { Deployment } from "@intentius/chant-lexicon-k8s/generated";
+import yaml from "js-yaml";
+
+export interface HelmRenderProps {
+  /** Logical name for the render (used in cache key + composite name). */
+  name: string;
+  /** Chart repo URL, e.g. https://charts.external-secrets.io */
+  repo: string;
+  /** Chart name, e.g. "external-secrets" */
+  chart: string;
+  /** Pinned chart version, e.g. "0.10.4" */
+  version: string;
+  /** Target namespace passed to `helm template --namespace`. */
+  namespace?: string;
+  /** Also emit a Namespace manifest. Default: false. */
+  createNamespace?: boolean;
+  /** Helm values overrides (written to a values.yaml then passed via -f). */
+  values?: Record<string, unknown>;
+  /**
+   * Skip the on-disk cache. Default: false. Tests pass `true` to force a
+   * fresh render.
+   */
+  noCache?: boolean;
+}
+
+interface RenderedDoc {
+  apiVersion?: string;
+  kind?: string;
+  metadata?: { name?: string; namespace?: string; [k: string]: unknown };
+  [k: string]: unknown;
+}
+
+const CACHE_ROOT = join(homedir(), ".chant", "helm-renders");
+
+function cacheKey(props: HelmRenderProps): string {
+  const stable = JSON.stringify({
+    repo: props.repo,
+    chart: props.chart,
+    version: props.version,
+    namespace: props.namespace ?? null,
+    values: props.values ?? null,
+  });
+  return createHash("sha256").update(stable).digest("hex").slice(0, 16);
+}
+
+function renderViaHelm(props: HelmRenderProps): string {
+  // Write values overrides to a tempfile if any.
+  let valuesArgs: string[] = [];
+  if (props.values && Object.keys(props.values).length > 0) {
+    const valuesPath = join(tmpdir(), `chant-helm-values-${cacheKey(props)}.yaml`);
+    writeFileSync(valuesPath, yaml.dump(props.values));
+    valuesArgs = ["--values", valuesPath];
+  }
+
+  // When `repo` is set, helm fetches the chart by name+version from the repo.
+  // When `repo` is absent, treat `chart` as a local path.
+  const fetchArgs: string[] = [];
+  if (props.repo) {
+    fetchArgs.push("--repo", props.repo);
+    if (props.version) fetchArgs.push("--version", props.version);
+  }
+
+  const args = [
+    "template",
+    props.name,
+    props.chart,
+    ...fetchArgs,
+    ...(props.namespace ? ["--namespace", props.namespace] : []),
+    ...valuesArgs,
+  ];
+
+  try {
+    const out = execFileSync("helm", args, {
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "pipe"],
+      maxBuffer: 16 * 1024 * 1024,
+    });
+    return out;
+  } catch (err) {
+    const stderr =
+      err && typeof err === "object" && "stderr" in err
+        ? String((err as { stderr: unknown }).stderr)
+        : String(err);
+    throw new Error(
+      `HelmRender failed for ${props.repo}/${props.chart}@${props.version}:\n${stderr}\n` +
+        `Hint: ensure the 'helm' CLI is on PATH (helm version) and the chart is reachable.`,
+    );
+  }
+}
+
+function loadOrRender(props: HelmRenderProps): string {
+  if (props.noCache) {
+    return renderViaHelm(props);
+  }
+  const cacheDir = join(CACHE_ROOT, cacheKey(props));
+  const cachePath = join(cacheDir, "manifests.yaml");
+  if (existsSync(cachePath)) {
+    return readFileSync(cachePath, "utf8");
+  }
+  const out = renderViaHelm(props);
+  try {
+    mkdirSync(cacheDir, { recursive: true });
+    writeFileSync(cachePath, out);
+  } catch {
+    // Cache write failure is non-fatal — the render is still in memory.
+  }
+  return out;
+}
+
+function parseMultiDoc(text: string): RenderedDoc[] {
+  const docs = yaml.loadAll(text);
+  return docs
+    .filter((d): d is RenderedDoc => d !== null && typeof d === "object")
+    .filter((d) => d.kind && d.apiVersion);
+}
+
+/**
+ * Sanitize an arbitrary string into a valid TS/JS identifier suffix.
+ * Used to derive Composite Members keys from manifest kind+name pairs.
+ */
+function safeKey(input: string): string {
+  return input.replace(/[^a-zA-Z0-9_]/g, "_");
+}
+
+export const HelmRender = Composite<HelmRenderProps>((props) => {
+  const yamlText = loadOrRender(props);
+  const docs = parseMultiDoc(yamlText);
+
+  const out: Record<string, InstanceType<typeof Deployment>> = {};
+
+  if (props.createNamespace && props.namespace) {
+    out["__namespace"] = new Deployment({
+      apiVersion: "v1",
+      kind: "Namespace",
+      metadata: { name: props.namespace },
+    } as Record<string, unknown>);
+  }
+
+  const usedKeys = new Set<string>();
+  for (let i = 0; i < docs.length; i++) {
+    const doc = docs[i];
+    const kind = doc.kind ?? "Unknown";
+    const name = doc.metadata?.name ?? `doc${i}`;
+    let key = safeKey(`${kind}_${name}`);
+    // Disambiguate on collision (e.g. same kind+name across docs).
+    let collisionN = 2;
+    while (usedKeys.has(key)) {
+      key = `${safeKey(`${kind}_${name}`)}_${collisionN++}`;
+    }
+    usedKeys.add(key);
+    out[key] = new Deployment(doc as Record<string, unknown>);
+  }
+
+  return out;
+}, "HelmRender");

package/src/serializer.test.ts

@@ -1,8 +1,9 @@
-import { describe, test, expect } from "bun:test";
+import { describe, test, expect } from "vitest";
 import { createResource, createProperty } from "@intentius/chant/runtime";
 import type { Declarable } from "@intentius/chant/declarable";
 import type { SerializerResult } from "@intentius/chant/serializer";
 import { helmSerializer } from "./serializer";
+import { generateHelpers } from "./helpers";
 import { Chart, Values, ValuesOverride, HelmNotes, HelmTest, HelmHook, HelmDependency, HelmMaintainer, HelmCRD } from "./resources";
 import { values, include, printf, toYaml, quote, helmDefault, required, If, ElseIf, Range, With, Release, ChartRef, Capabilities, runtimeSlot } from "./intrinsics";
 
@@ -318,12 +319,12 @@ describe("resource-level If", () => {
     const template = result.files!["templates/ingress.yaml"];
 
     expect(template).toBeDefined();
-    expect(template).toStartWith("{{- if .Values.ingress.enabled }}\n");
+    expect(template.startsWith("{{- if .Values.ingress.enabled }}\n")).toBe(true);
     expect(template).toContain("apiVersion: networking.k8s.io/v1");
     expect(template).toContain("kind: Ingress");
     expect(template).toContain('{{ include "test.fullname" . }}');
     expect(template).toContain("{{ .Values.ingress.host }}");
-    expect(template.trimEnd()).toEndWith("{{- end }}");
+    expect(template.trimEnd().endsWith("{{- end }}")).toBe(true);
   });
 
   test("does not wrap non-conditional resources", () => {
@@ -905,7 +906,6 @@ describe("ValuesOverride serialization", () => {
 
 describe("helpers", () => {
   test("generateHelpers includes all standard templates", () => {
-    const { generateHelpers } = require("./helpers");
     const content = generateHelpers({ chartName: "my-chart" });
 
     expect(content).toContain('define "my-chart.name"');
@@ -917,7 +917,6 @@ describe("helpers", () => {
   });
 
   test("generateHelpers respects includeServiceAccount=false", () => {
-    const { generateHelpers } = require("./helpers");
     const content = generateHelpers({ chartName: "test", includeServiceAccount: false });
 
     expect(content).toContain('define "test.name"');

package/src/serializer.ts

@@ -111,7 +111,7 @@ function emitHelmYAML(value: unknown, indent: number, valuesContext: boolean = f
 
   // Detect HelmTpl / Intrinsic objects via INTRINSIC_MARKER before string check
   if (typeof value === "object" && value !== null && INTRINSIC_MARKER in value) {
-    const tplObj = value as { toJSON(): unknown };
+    const tplObj = value as unknown as { toJSON(): unknown };
     if (valuesContext) {
       // In values.yaml context: emit empty placeholder — actual value comes from override files
       return "''";

package/src/validate-cli.ts

@@ -1,4 +1,4 @@
-#!/usr/bin/env bun
+#!/usr/bin/env tsx
 /**
  * CLI entry point for Helm lexicon validation.
  */

package/src/validate.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";