@intentius/chant-lexicon-helm 0.124.31 → 0.124.33

package/dist/render-store.js

@@ -0,0 +1,401 @@
+/**
+ * RenderManifest + content-addressed render storage (#1238, epic #1228
+ * Phase 2).
+ *
+ * #1237 gave a pinned render its identities — `inputDigest` over the
+ * declared inputs, `contentDigest` over the canonical rendered bytes. This
+ * module makes the render durable: the canonical bytes land in a
+ * content-addressed store keyed by `contentDigest`, and a `RenderManifest`
+ * — modeled on core's `BuildArchiveManifest`
+ * (packages/core/src/components/verbs/build-archive.ts) — records what the
+ * bytes are, what produced them, and how to find each document inside them.
+ *
+ * Storage layout, under `~/.chant/helm-renders/` (override with
+ * `CHANT_HELM_RENDER_ROOT`):
+ *
+ * ```
+ * sha256-<64 hex>/          one per distinct contentDigest
+ *   content.yaml            the canonical rendered bytes (canonicalizeRender)
+ *   manifest.json           the RenderManifest
+ * inputs/<64 hex>.json      inputs index: full-render-inputs key -> digests
+ * ```
+ *
+ * The `sha256-<hex>` entries are the new root the issue asks for: the
+ * pre-#1238 cache keyed entries by a *truncated, input-derived* hash
+ * (16 hex characters, no algorithm prefix), which is a cache key, not an
+ * artifact identity. Those legacy entries are left exactly where they are —
+ * unpinned renders keep using them — and pinned renders write here instead.
+ * No migration: a truncated key cannot be turned back into a digest.
+ *
+ * Two renders that produce the same bytes share one `sha256-<hex>` entry —
+ * the content file and manifest are written once and never rewritten
+ * (first writer wins; the store is immutable, like a build archive entry).
+ * Dedup falls out of content addressing rather than being a feature.
+ *
+ * The inputs index preserves cache-hit behavior: before shelling out to
+ * helm, `HelmRender` computes the full-inputs key and reads
+ * `inputs/<key>.json` to find the bytes a previous identical render stored.
+ * The index key deliberately differs from `inputDigest`: the release name
+ * and namespace are baked into the rendered bytes (`.Release.Name`,
+ * `--namespace`) but are excluded from `inputDigest` because the release
+ * ledger uses that digest as a cross-environment join key (see
+ * `helmInputDigest` in ./render-digest.ts). A cache must key on everything
+ * that changes the bytes, so the index key includes both.
+ *
+ * Retention: none, deliberately. The build archive this is modeled on has
+ * no garbage collection — an archive entry lives until someone deletes it —
+ * and the pre-#1238 render cache behaved the same way. This store follows
+ * suit: entries accumulate until removed by hand. If the archive ever grows
+ * a retention story, this store should adopt the same one.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { canonicalJson } from "@intentius/chant/effect-receipt";
+import yaml from "js-yaml";
+import { canonicalizeRender, helmContentDigest, helmInputDigest } from "./render-digest.js";
+// ── store location ────────────────────────────────────────────────────────
+/**
+ * Root of the render store. `CHANT_HELM_RENDER_ROOT` overrides the default
+ * `~/.chant/helm-renders` — the same directory the legacy input-keyed cache
+ * lives in; the two coexist because legacy entries are bare 16-hex names
+ * and store entries are `sha256-` prefixed.
+ */
+export function renderStoreRoot() {
+    return process.env.CHANT_HELM_RENDER_ROOT ?? join(homedir(), ".chant", "helm-renders");
+}
+const DIGEST_RE = /^sha256:[0-9a-f]{64}$/;
+/** `sha256:<hex>` -> the store directory name `sha256-<hex>` (colons are not filesystem-safe everywhere). */
+function digestDirName(contentDigest) {
+    if (!DIGEST_RE.test(contentDigest)) {
+        throw new Error(`not a content digest: ${JSON.stringify(contentDigest)} (expected "sha256:<64 hex>")`);
+    }
+    return contentDigest.replace(":", "-");
+}
+function contentPath(root, contentDigest) {
+    return join(root, digestDirName(contentDigest), "content.yaml");
+}
+function manifestPath(root, contentDigest) {
+    return join(root, digestDirName(contentDigest), "manifest.json");
+}
+/**
+ * Cache key over *everything* that changes a pinned render's bytes — a
+ * strict superset of `helmInputDigest`'s inputs (adds release name,
+ * namespace, and the profile's declared name, mirroring the legacy cache
+ * key's fields). 64 hex characters, no prefix: this is a lookup key, not an
+ * artifact identity.
+ */
+export function renderCacheKey(source) {
+    const input = {
+        chart: source.chart,
+        chartVersion: source.chartVersion ?? null,
+        releaseName: source.releaseName,
+        namespace: source.namespace ?? null,
+        values: source.values ?? {},
+        capabilityProfile: {
+            name: source.capabilityProfile.name,
+            kubeVersion: source.capabilityProfile.kubeVersion,
+            apiVersions: [...(source.capabilityProfile.apiVersions ?? [])].sort(),
+        },
+    };
+    return createHash("sha256").update(canonicalJson(input), "utf8").digest("hex");
+}
+const CACHE_KEY_RE = /^[0-9a-f]{64}$/;
+function inputsIndexPath(root, cacheKey) {
+    if (!CACHE_KEY_RE.test(cacheKey)) {
+        throw new Error(`not a render cache key: ${JSON.stringify(cacheKey)} (expected 64 hex characters)`);
+    }
+    return join(root, "inputs", `${cacheKey}.json`);
+}
+// ── values digest ─────────────────────────────────────────────────────────
+/**
+ * `sha256:` over the canonical JSON of the resolved values alone — the
+ * `valuesDigest` half of the ledger's input-side join key
+ * `(chart, chartVersion, valuesDigest)`. Absent values digest as `{}`,
+ * matching `helmInputDigest`'s treatment.
+ */
+export function helmValuesDigest(values) {
+    return `sha256:${createHash("sha256").update(canonicalJson(values ?? {}), "utf8").digest("hex")}`;
+}
+// ── chant version ─────────────────────────────────────────────────────────
+function readVersionAbove(startDir) {
+    let dir = startDir;
+    for (let i = 0; i < 6; i++) {
+        const candidate = join(dir, "package.json");
+        if (existsSync(candidate)) {
+            try {
+                const version = JSON.parse(readFileSync(candidate, "utf8")).version;
+                if (version)
+                    return version;
+            }
+            catch {
+                // unreadable package.json — fall through to the caller's fallback
+            }
+            return undefined;
+        }
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return undefined;
+}
+/**
+ * The core package's version, read from its `package.json` next to wherever
+ * `@intentius/chant` resolves from here. Falls back to this lexicon's own
+ * version (the two release in lockstep), then `"unknown"` — a manifest is
+ * never blocked on version discovery.
+ */
+function chantVersion() {
+    try {
+        const req = createRequire(import.meta.url);
+        const fromCore = readVersionAbove(dirname(req.resolve("@intentius/chant")));
+        if (fromCore)
+            return fromCore;
+    }
+    catch {
+        // resolution failed (unusual layout) — use the lexicon's own version
+    }
+    return readVersionAbove(dirname(fileURLToPath(import.meta.url))) ?? "unknown";
+}
+/**
+ * Split a canonical stream (canonicalizeRender output) into its documents
+ * with byte-accurate offsets. Boundaries are column-0 `---` lines — the
+ * canonical form introduces every document with one, and no canonical
+ * document body can contain one (block-scalar content is always indented).
+ */
+function canonicalSegments(canonical) {
+    const marks = [];
+    const re = /^---$/gm;
+    let m;
+    while ((m = re.exec(canonical)) !== null)
+        marks.push(m.index);
+    const segments = [];
+    let lastCharEnd = 0;
+    let lastByteEnd = 0;
+    for (let k = 0; k < marks.length; k++) {
+        const charStart = canonical.indexOf("\n", marks[k]) + 1; // just past "---\n"
+        const charEnd = k + 1 < marks.length ? marks[k + 1] : canonical.length;
+        const byteStart = lastByteEnd + Buffer.byteLength(canonical.slice(lastCharEnd, charStart), "utf8");
+        const text = canonical.slice(charStart, charEnd);
+        const byteLength = Buffer.byteLength(text, "utf8");
+        segments.push({ text, byteStart, byteLength });
+        lastCharEnd = charEnd;
+        lastByteEnd = byteStart + byteLength;
+    }
+    return segments;
+}
+const SOURCE_LINE = /^# Source: (\S+)$/m;
+/**
+ * Build the document index over a canonical stream: for every identifiable
+ * document (it parses and carries `kind` + `metadata.name`), its
+ * kind/namespace/name identity, byte span, and per-document digest.
+ * Returns the index and the total document count — the count includes
+ * documents the index could not identify, so `docCount` is always the
+ * number of documents the artifact carries.
+ */
+export function indexRenderDocuments(canonical) {
+    const segments = canonicalSegments(canonical);
+    const documents = [];
+    for (const segment of segments) {
+        let parsed;
+        try {
+            parsed = yaml.load(segment.text);
+        }
+        catch {
+            continue; // verbatim (unparseable) document — counted, not indexed
+        }
+        if (parsed === null || typeof parsed !== "object")
+            continue;
+        const doc = parsed;
+        if (typeof doc.kind !== "string" || typeof doc.metadata?.name !== "string")
+            continue;
+        documents.push({
+            kind: doc.kind,
+            apiVersion: typeof doc.apiVersion === "string" ? doc.apiVersion : "",
+            name: doc.metadata.name,
+            namespace: typeof doc.metadata.namespace === "string" ? doc.metadata.namespace : null,
+            source: segment.text.match(SOURCE_LINE)?.[1] ?? null,
+            start: segment.byteStart,
+            length: segment.byteLength,
+            digest: `sha256:${createHash("sha256").update(segment.text, "utf8").digest("hex")}`,
+        });
+    }
+    return { documents, docCount: segments.length };
+}
+/**
+ * Persist one pinned render: canonical bytes under their `contentDigest`,
+ * the `RenderManifest` beside them, and an inputs-index entry so an
+ * identical future render is a cache hit.
+ *
+ * Content-addressed entries are immutable: when the digest directory
+ * already holds a manifest, both files are left as they are and the
+ * existing manifest is returned (`deduplicated: true`). The inputs index is
+ * still written — a new input combination can legitimately map to bytes the
+ * store already holds.
+ *
+ * Refuses an unpinned render (no capability profile) with the specific
+ * reason: no profile means the bytes depend on the local helm binary's
+ * defaulted capabilities, so they have no stable content identity to store
+ * under.
+ */
+export function persistHelmRender(input) {
+    if (!input.capabilityProfile) {
+        throw new Error(`refusing to persist unpinned render "${input.releaseName}" (${input.chart}): ` +
+            `no capability profile is declared, so the rendered bytes are a function of the local ` +
+            `helm binary's defaulted capabilities and have no stable content identity to store under. ` +
+            `Declare capabilityProfile on the HelmRender to pin it (#1235).`);
+    }
+    const profile = input.capabilityProfile;
+    const root = input.root ?? renderStoreRoot();
+    const canonical = canonicalizeRender(input.rendered);
+    const contentDigest = helmContentDigest(input.rendered);
+    const chartRef = input.repo ? `${input.repo}/${input.chart}` : input.chart;
+    const inputDigest = helmInputDigest({
+        chart: chartRef,
+        chartVersion: input.chartVersion,
+        values: input.values ?? {},
+        capabilityProfile: { kubeVersion: profile.kubeVersion, apiVersions: profile.apiVersions },
+    });
+    const dir = join(root, digestDirName(contentDigest));
+    const existing = loadRenderManifest(contentDigest, { root });
+    let manifest;
+    let deduplicated = false;
+    if (existing) {
+        // First writer wins — the entry is immutable, like a build archive's.
+        manifest = existing;
+        deduplicated = true;
+    }
+    else {
+        const { documents, docCount } = indexRenderDocuments(canonical);
+        manifest = {
+            version: 1,
+            chart: input.chart,
+            chartVersion: input.chartVersion ?? null,
+            repo: input.repo ?? null,
+            releaseName: input.releaseName,
+            namespace: input.namespace ?? null,
+            valuesDigest: helmValuesDigest(input.values),
+            inputDigest,
+            capabilityProfile: {
+                cluster: profile.name,
+                kubeVersion: profile.kubeVersion,
+                apiVersions: profile.apiVersions ?? [],
+            },
+            contentDigest,
+            docCount,
+            documents,
+            renderedAt: (input.now ?? (() => new Date()))().toISOString(),
+            helmVersion: input.helmVersion ?? "unknown",
+            chantVersion: chantVersion(),
+            sourceRef: input.sourceRef ?? null,
+            coalescedValuesDigest: input.coalescedValuesDigest ?? null,
+            valueSources: input.valueSources ?? null,
+        };
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(contentPath(root, contentDigest), canonical);
+        writeFileSync(manifestPath(root, contentDigest), JSON.stringify(manifest, null, 2) + "\n");
+    }
+    const key = renderCacheKey({
+        chart: chartRef,
+        chartVersion: input.chartVersion,
+        releaseName: input.releaseName,
+        namespace: input.namespace,
+        values: input.values,
+        capabilityProfile: profile,
+    });
+    const indexEntry = { version: 1, inputDigest, contentDigest };
+    mkdirSync(join(root, "inputs"), { recursive: true });
+    writeFileSync(inputsIndexPath(root, key), JSON.stringify(indexEntry, null, 2) + "\n");
+    return { manifest, dir, deduplicated };
+}
+// ── read path ─────────────────────────────────────────────────────────────
+/** Load the `RenderManifest` stored under a content digest, or `undefined` when the store has no such entry. */
+export function loadRenderManifest(contentDigest, opts) {
+    const root = opts?.root ?? renderStoreRoot();
+    const path = manifestPath(root, contentDigest);
+    if (!existsSync(path))
+        return undefined;
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.version !== 1) {
+        throw new Error(`render manifest ${path} has unsupported version ${String(parsed.version)}`);
+    }
+    return parsed;
+}
+/** Load the canonical rendered bytes stored under a content digest, or `undefined` when absent. */
+export function loadRenderContent(contentDigest, opts) {
+    const root = opts?.root ?? renderStoreRoot();
+    const path = contentPath(root, contentDigest);
+    if (!existsSync(path))
+        return undefined;
+    return readFileSync(path, "utf8");
+}
+/** Resolve a full-inputs cache key through the inputs index, or `undefined` on a miss. */
+export function findRenderByCacheKey(cacheKey, opts) {
+    const root = opts?.root ?? renderStoreRoot();
+    const path = inputsIndexPath(root, cacheKey);
+    if (!existsSync(path))
+        return undefined;
+    const parsed = JSON.parse(readFileSync(path, "utf8"));
+    if (parsed.version !== 1)
+        return undefined;
+    return parsed;
+}
+/**
+ * Every manifest in the store, sorted by `renderedAt` then `contentDigest`
+ * for a stable listing. Entries whose manifest is missing or unreadable are
+ * skipped — a listing never fails on one corrupt entry. This is the query
+ * surface the diff issues (#1249/#1250) resolve digests against.
+ */
+export function listRenderManifests(opts) {
+    const root = opts?.root ?? renderStoreRoot();
+    if (!existsSync(root))
+        return [];
+    const manifests = [];
+    for (const entry of readdirSync(root)) {
+        if (!/^sha256-[0-9a-f]{64}$/.test(entry))
+            continue;
+        try {
+            const manifest = loadRenderManifest(entry.replace("-", ":"), { root });
+            if (manifest)
+                manifests.push(manifest);
+        }
+        catch {
+            // corrupt entry — skip it, never fail the listing
+        }
+    }
+    manifests.sort((a, b) => a.renderedAt === b.renderedAt
+        ? a.contentDigest.localeCompare(b.contentDigest)
+        : a.renderedAt.localeCompare(b.renderedAt));
+    return manifests;
+}
+/**
+ * Resolve one document by kind/namespace/name to its exact bytes inside a
+ * stored render, via the manifest's document index. The slice is verified
+ * against the entry's per-document digest before being returned — corrupt
+ * content is an error, never silently wrong bytes. `undefined` means the
+ * store has no such render or the index has no such document.
+ */
+export function readRenderDocument(contentDigest, ref, opts) {
+    const root = opts?.root ?? renderStoreRoot();
+    const manifest = loadRenderManifest(contentDigest, { root });
+    if (!manifest)
+        return undefined;
+    const wantNs = ref.namespace ?? null;
+    const entry = manifest.documents.find((d) => d.kind === ref.kind && d.name === ref.name && d.namespace === wantNs);
+    if (!entry)
+        return undefined;
+    const content = loadRenderContent(contentDigest, { root });
+    if (content === undefined)
+        return undefined;
+    const bytes = Buffer.from(content, "utf8").subarray(entry.start, entry.start + entry.length);
+    const digest = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+    if (digest !== entry.digest) {
+        throw new Error(`stored render ${contentDigest} is corrupt: document ${entry.kind}/${entry.name} ` +
+            `digests to ${digest}, manifest says ${entry.digest}`);
+    }
+    return { entry, text: bytes.toString("utf8") };
+}

package/dist/render-wrapper.js

@@ -0,0 +1,164 @@
+/**
+ * Structure-preserving render wrapper (#1239, epic #1228 Phase 3).
+ *
+ * Turns a pinned render's document stream into chant-shaped routing groups
+ * WITHOUT restructuring the documents. Structure-preserving means the bytes
+ * that deploy are the bytes the render store recorded — this module only
+ * routes and labels; it never re-serializes, reorders lines, or edits a
+ * document. Each `RoutedDocument.text` is the exact document text from the
+ * input stream.
+ *
+ * Routing is by origin, not by kind. `helm template` stamps every document
+ * with `# Source: <chart>/<path>`, and the discriminator is whether that
+ * path contains a `crds/` **segment** (`(^|/)crds/` — `isCrdSource` from
+ * the #1234 classifier seeds):
+ *
+ * - A `crds/`-segment origin routes to the CRD group — the wrapper's
+ *   `crds/`. Segment matching is load-bearing: a subchart's CRDs arrive as
+ *   `charts/<child>/crds/<file>`, so a prefix rule catches none of them and
+ *   would route every subchart CRD into `templates/`, making it deletable
+ *   on uninstall (epic findings 4, 10 — the A/B test showed a flat wrap
+ *   converts `helm uninstall` from safe to data-destroying).
+ * - A hook-annotated template document (`helm.sh/hook` in
+ *   `metadata.annotations`) routes to its own group, annotations intact.
+ *   Hooks survive pinning (epic finding 5); they are surfaced separately so
+ *   the install path can account for them, never silently dropped.
+ * - Everything else routes to the main group — the wrapper's `templates/`.
+ *   A template-rendered `CustomResourceDefinition` stays here, because the
+ *   `crds/`-segment is the discriminator, not the kind: a chart that
+ *   templates its CRDs opted into template lifecycle semantics (upgrades
+ *   and deletes apply to them), and moving them to `crds/` would change
+ *   that. The routing notes it with a warning so the choice is visible.
+ *
+ * Aliased dependencies emit duplicate CRDs (epic finding 11): the same
+ * dependency included twice under an alias renders its `crds/` once per
+ * instance — two documents, one distinct CRD. The stored artifact keeps
+ * both (canonicalization is order- and duplicate-preserving), but a wrapper
+ * chart's `crds/` holds each CRD once, so the routed CRD group deduplicates
+ * by `(group, kind)`: the first occurrence wins and a warning names both
+ * sources. A CRD document that cannot be identified (unparseable, or
+ * missing `spec.group` / `spec.names.kind`) is never deduplicated — the
+ * routing must not silently drop what it cannot identify.
+ *
+ * The wrapper inherits the source chart's name and version (epic
+ * Decisions), keeping `helm history` continuous across the pinned
+ * migration; `RoutedRender.chart` / `chartVersion` carry them.
+ *
+ * This is the seam the pinned-install path (#1242) consumes:
+ * `routeStoredRender(contentDigest)` loads a stored render's canonical
+ * bytes and manifest and routes them.
+ */
+import yaml from "js-yaml";
+import { isCrdSource, sourcePath, splitDocuments } from "./pinnability/render-stream.js";
+import { loadRenderContent, loadRenderManifest } from "./render-store.js";
+const CRD_KIND = "CustomResourceDefinition";
+/**
+ * Parse a document just far enough to label it. Parsing is for labels only —
+ * the routed text is always the original bytes. An unparseable document
+ * labels as `null`s and routes to the main group.
+ */
+function parseForLabels(doc) {
+    let parsed;
+    try {
+        parsed = yaml.load(doc);
+    }
+    catch {
+        return { kind: null, apiVersion: null, name: null, hook: false, crdKey: null };
+    }
+    if (parsed === null || typeof parsed !== "object") {
+        return { kind: null, apiVersion: null, name: null, hook: false, crdKey: null };
+    }
+    const obj = parsed;
+    const kind = typeof obj.kind === "string" ? obj.kind : null;
+    const annotations = obj.metadata?.annotations;
+    const hook = annotations !== null &&
+        typeof annotations === "object" &&
+        Object.prototype.hasOwnProperty.call(annotations, "helm.sh/hook");
+    let crdKey = null;
+    if (kind === CRD_KIND) {
+        const group = obj.spec?.group;
+        const namesKind = obj.spec?.names?.kind;
+        if (typeof group === "string" && typeof namesKind === "string") {
+            crdKey = `${group}/${namesKind}`;
+        }
+    }
+    return {
+        kind,
+        apiVersion: typeof obj.apiVersion === "string" ? obj.apiVersion : null,
+        name: typeof obj.metadata?.name === "string" ? obj.metadata.name : null,
+        hook,
+        crdKey,
+    };
+}
+/**
+ * Route a rendered stream (canonical or raw `helm template` output) into
+ * `RoutedRender` groups. Pure over the stream: no store access, no helm.
+ */
+export function routeRender(rendered, opts) {
+    const routed = {
+        chart: opts.chart,
+        chartVersion: opts.chartVersion ?? null,
+        crds: [],
+        hooks: [],
+        main: [],
+        warnings: [],
+    };
+    const firstCrdByKey = new Map();
+    for (const text of splitDocuments(rendered)) {
+        const source = sourcePath(text) ?? null;
+        const labels = parseForLabels(text);
+        const doc = {
+            text,
+            source,
+            kind: labels.kind,
+            apiVersion: labels.apiVersion,
+            name: labels.name,
+        };
+        if (source !== null && isCrdSource(source)) {
+            if (labels.crdKey !== null) {
+                const first = firstCrdByKey.get(labels.crdKey);
+                if (first) {
+                    routed.warnings.push({
+                        code: "duplicate-crd",
+                        message: `duplicate CRD ${labels.crdKey}: keeping ${first.source ?? "<no source>"}, ` +
+                            `dropping ${source} (an aliased dependency emits the same CRD once per instance; ` +
+                            `a wrapper chart's crds/ holds it once, matching what helm installs)`,
+                    });
+                    continue;
+                }
+                firstCrdByKey.set(labels.crdKey, doc);
+            }
+            routed.crds.push(doc);
+            continue;
+        }
+        if (labels.kind === CRD_KIND) {
+            // Template-rendered CRD: the crds/-segment is the discriminator, not
+            // the kind. It stays in its rendered group with template lifecycle
+            // semantics — noted, never moved.
+            routed.warnings.push({
+                code: "template-crd",
+                message: `CustomResourceDefinition ${labels.name ?? "<unnamed>"} is template-rendered ` +
+                    `(source: ${source ?? "<none>"}), not shipped in crds/ — it stays in the main set ` +
+                    `with template lifecycle semantics: helm upgrades and deletes will apply to it`,
+            });
+        }
+        (labels.hook ? routed.hooks : routed.main).push(doc);
+    }
+    return routed;
+}
+/**
+ * Route a stored pinned render by its `contentDigest`: loads the canonical
+ * bytes and the `RenderManifest` from the render store (#1238) and routes
+ * them, inheriting the manifest's chart name and version. This is the seam
+ * the pinned-install path (#1242) consumes. `undefined` when the store has
+ * no such entry.
+ */
+export function routeStoredRender(contentDigest, opts) {
+    const manifest = loadRenderManifest(contentDigest, opts);
+    if (!manifest)
+        return undefined;
+    const content = loadRenderContent(contentDigest, opts);
+    if (content === undefined)
+        return undefined;
+    return routeRender(content, { chart: manifest.chart, chartVersion: manifest.chartVersion });
+}