@intentius/chant-lexicon-helm 0.124.31 → 0.124.33

package/dist/import/generator.js

@@ -0,0 +1,292 @@
+/**
+ * TypeScript code generator for Helm chart import.
+ *
+ * Converts a TemplateIR (from parsed Helm charts) into TypeScript source code
+ * using @intentius/chant-lexicon-helm and @intentius/chant-lexicon-k8s constructors,
+ * mapping Go template expressions to Helm intrinsics.
+ */
+/** K8s type to class name mapping. */
+const K8S_TYPE_TO_CLASS = {
+    "K8s::Core::Pod": "Pod",
+    "K8s::Core::Service": "Service",
+    "K8s::Core::ConfigMap": "ConfigMap",
+    "K8s::Core::Secret": "Secret",
+    "K8s::Core::ServiceAccount": "ServiceAccount",
+    "K8s::Apps::Deployment": "Deployment",
+    "K8s::Apps::StatefulSet": "StatefulSet",
+    "K8s::Apps::DaemonSet": "DaemonSet",
+    "K8s::Batch::Job": "Job",
+    "K8s::Batch::CronJob": "CronJob",
+    "K8s::Networking::Ingress": "Ingress",
+    "K8s::Networking::NetworkPolicy": "NetworkPolicy",
+    "K8s::Rbac::Role": "Role",
+    "K8s::Rbac::ClusterRole": "ClusterRole",
+    "K8s::Rbac::RoleBinding": "RoleBinding",
+    "K8s::Rbac::ClusterRoleBinding": "ClusterRoleBinding",
+    "K8s::Autoscaling::HorizontalPodAutoscaler": "HorizontalPodAutoscaler",
+    "K8s::Policy::PodDisruptionBudget": "PodDisruptionBudget",
+};
+/** Helm type to class name mapping. */
+const HELM_TYPE_TO_CLASS = {
+    "Helm::Chart": "Chart",
+    "Helm::Values": "Values",
+    "Helm::Notes": "HelmNotes",
+};
+export class HelmGenerator {
+    generate(ir) {
+        const lines = [];
+        const helmImports = new Set();
+        const k8sImports = new Set();
+        const intrinsicImports = new Set();
+        // Classify resources and collect needed imports
+        for (const resource of ir.resources) {
+            const helmClass = HELM_TYPE_TO_CLASS[resource.type];
+            if (helmClass) {
+                helmImports.add(helmClass);
+            }
+            else {
+                const k8sClass = this.resolveK8sClass(resource.type);
+                if (k8sClass)
+                    k8sImports.add(k8sClass);
+            }
+            // Scan for template expressions to determine intrinsic imports
+            this.collectIntrinsicImports(resource, intrinsicImports);
+        }
+        // Emit imports
+        if (helmImports.size > 0) {
+            lines.push(`import { ${[...helmImports].sort().join(", ")} } from "@intentius/chant-lexicon-helm";`);
+        }
+        if (intrinsicImports.size > 0) {
+            lines.push(`import { ${[...intrinsicImports].sort().join(", ")} } from "@intentius/chant-lexicon-helm";`);
+        }
+        if (k8sImports.size > 0) {
+            lines.push(`import { ${[...k8sImports].sort().join(", ")} } from "@intentius/chant-lexicon-k8s";`);
+        }
+        lines.push("");
+        // Emit resources
+        for (const resource of ir.resources) {
+            const cls = HELM_TYPE_TO_CLASS[resource.type] ?? this.resolveK8sClass(resource.type);
+            if (!cls) {
+                lines.push(`// TODO: unsupported type ${resource.type} (${resource.logicalId})`);
+                lines.push("");
+                continue;
+            }
+            // Replace placeholders with intrinsic calls in properties
+            const props = this.substituteExpressions(resource.properties, resource.metadata?.templateExpressions);
+            const propsStr = this.emitProps(props, 1);
+            lines.push(`export const ${resource.logicalId} = new ${cls}(${propsStr});`);
+            lines.push("");
+        }
+        return [{ path: "chart.ts", content: lines.join("\n") }];
+    }
+    resolveK8sClass(type) {
+        if (K8S_TYPE_TO_CLASS[type])
+            return K8S_TYPE_TO_CLASS[type];
+        const parts = type.split("::");
+        if (parts.length === 3 && parts[0] === "K8s")
+            return parts[2];
+        return undefined;
+    }
+    collectIntrinsicImports(resource, imports) {
+        const exprs = resource.metadata?.templateExpressions;
+        if (!exprs)
+            return;
+        for (const entry of Object.values(exprs)) {
+            const kind = entry.kind;
+            switch (kind) {
+                case "values":
+                    imports.add("values");
+                    break;
+                case "release":
+                    imports.add("Release");
+                    break;
+                case "chart":
+                    imports.add("ChartRef");
+                    break;
+                case "include":
+                    imports.add("include");
+                    break;
+                case "toYaml":
+                    imports.add("toYaml");
+                    imports.add("values");
+                    break;
+                case "required":
+                    imports.add("required");
+                    imports.add("values");
+                    break;
+                case "default":
+                    imports.add("helmDefault");
+                    imports.add("values");
+                    break;
+                case "printf":
+                    imports.add("printf");
+                    break;
+                case "quote":
+                    imports.add("quote");
+                    imports.add("values");
+                    break;
+                case "lookup":
+                    imports.add("lookup");
+                    break;
+                case "tpl":
+                    imports.add("tpl");
+                    break;
+            }
+        }
+    }
+    /**
+     * Walk through properties, replacing placeholder strings with intrinsic call representations.
+     */
+    substituteExpressions(props, exprs) {
+        if (!exprs)
+            return props;
+        return this.walkAndReplace(props, exprs);
+    }
+    walkAndReplace(value, exprs) {
+        if (typeof value === "string") {
+            // Check if the entire string is a placeholder
+            const expr = exprs[value];
+            if (expr) {
+                return { __intrinsicCall: this.expressionToIntrinsic(expr.expression, expr.kind) };
+            }
+            // Check if the string contains placeholders mixed with text
+            let result = value;
+            for (const [placeholder, entry] of Object.entries(exprs)) {
+                if (result.includes(placeholder)) {
+                    result = result.replace(placeholder, `\${${this.expressionToIntrinsic(entry.expression, entry.kind)}}`);
+                }
+            }
+            if (result !== value) {
+                return { __intrinsicCall: result };
+            }
+            return value;
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.walkAndReplace(item, exprs));
+        }
+        if (value && typeof value === "object") {
+            const result = {};
+            for (const [k, v] of Object.entries(value)) {
+                result[k] = this.walkAndReplace(v, exprs);
+            }
+            return result;
+        }
+        return value;
+    }
+    /**
+     * Convert a Go template expression to a TypeScript intrinsic call string.
+     */
+    expressionToIntrinsic(expression, kind) {
+        switch (kind) {
+            case "values": {
+                const path = expression.replace(/^\.Values\./, "");
+                return `values.${path}`;
+            }
+            case "release": {
+                const field = expression.replace(/^\.Release\./, "");
+                return `Release.${field}`;
+            }
+            case "chart": {
+                const field = expression.replace(/^\.Chart\./, "");
+                return `ChartRef.${field}`;
+            }
+            case "include": {
+                const match = expression.match(/^include\s+"([^"]+)"\s+(.+)$/);
+                if (match)
+                    return `include("${match[1]}")`;
+                return `include(${JSON.stringify(expression)})`;
+            }
+            case "toYaml": {
+                const match = expression.match(/toYaml\s+(.+?)(?:\s*\|\s*nindent\s+(\d+))?$/);
+                if (match) {
+                    const ref = this.refToIntrinsic(match[1]);
+                    return match[2] ? `toYaml(${ref}, ${match[2]})` : `toYaml(${ref})`;
+                }
+                return `toYaml(${JSON.stringify(expression)})`;
+            }
+            case "required": {
+                const match = expression.match(/^required\s+"([^"]+)"\s+(.+)$/);
+                if (match)
+                    return `required("${match[1]}", ${this.refToIntrinsic(match[2])})`;
+                return `required(${JSON.stringify(expression)})`;
+            }
+            case "default": {
+                const match = expression.match(/^default\s+"([^"]+)"\s+(.+)$/);
+                if (match)
+                    return `helmDefault("${match[1]}", ${this.refToIntrinsic(match[2])})`;
+                return `helmDefault(${JSON.stringify(expression)})`;
+            }
+            case "printf": {
+                const match = expression.match(/^printf\s+"([^"]+)"\s+(.+)$/);
+                if (match) {
+                    const args = match[2].split(/\s+/).map((a) => this.refToIntrinsic(a));
+                    return `printf("${match[1]}", ${args.join(", ")})`;
+                }
+                return `printf(${JSON.stringify(expression)})`;
+            }
+            case "quote":
+                return `quote(${this.refToIntrinsic(expression.replace(/\s*\|\s*quote\s*$/, ""))})`;
+            case "lookup":
+                return `lookup(${JSON.stringify(expression)})`;
+            case "tpl":
+                return `tpl(${JSON.stringify(expression)})`;
+            default:
+                return `/* ${expression} */`;
+        }
+    }
+    /**
+     * Convert a Go template reference to a TypeScript expression.
+     */
+    refToIntrinsic(ref) {
+        const trimmed = ref.trim();
+        if (trimmed.startsWith(".Values."))
+            return `values.${trimmed.slice(8)}`;
+        if (trimmed.startsWith(".Release."))
+            return `Release.${trimmed.slice(9)}`;
+        if (trimmed.startsWith(".Chart."))
+            return `ChartRef.${trimmed.slice(7)}`;
+        if (trimmed === ".")
+            return "context";
+        return JSON.stringify(trimmed);
+    }
+    emitProps(props, depth) {
+        const indent = "  ".repeat(depth);
+        const innerIndent = "  ".repeat(depth + 1);
+        const entries = [];
+        for (const [key, value] of Object.entries(props)) {
+            if (value === undefined || value === null)
+                continue;
+            entries.push(`${innerIndent}${key}: ${this.emitValue(value, depth + 1)},`);
+        }
+        if (entries.length === 0)
+            return "{}";
+        return `{\n${entries.join("\n")}\n${indent}}`;
+    }
+    emitValue(value, depth) {
+        if (value === null || value === undefined)
+            return "undefined";
+        // Intrinsic call placeholder
+        if (typeof value === "object" && value !== null && "__intrinsicCall" in value) {
+            return value.__intrinsicCall;
+        }
+        if (typeof value === "string")
+            return JSON.stringify(value);
+        if (typeof value === "number" || typeof value === "boolean")
+            return String(value);
+        if (Array.isArray(value)) {
+            if (value.length === 0)
+                return "[]";
+            const items = value.map((item) => this.emitValue(item, depth + 1));
+            const oneLine = `[${items.join(", ")}]`;
+            if (oneLine.length < 80)
+                return oneLine;
+            const indent = "  ".repeat(depth);
+            const innerIndent = "  ".repeat(depth + 1);
+            return `[\n${items.map((i) => `${innerIndent}${i},`).join("\n")}\n${indent}]`;
+        }
+        if (typeof value === "object") {
+            return this.emitProps(value, depth);
+        }
+        return String(value);
+    }
+}

package/dist/import/parser.js

@@ -0,0 +1,141 @@
+/**
+ * Helm chart parser for `chant import`.
+ *
+ * Parses an existing Helm chart directory (Chart.yaml, values.yaml, templates/)
+ * into the core TemplateIR format, preserving Go template expressions as metadata
+ * for reconstruction as Helm intrinsics.
+ */
+import { parseYAML } from "@intentius/chant/yaml";
+import { stripTemplateExpressions, classifyExpression } from "./template-stripper.js";
+/**
+ * Helm chart parser.
+ *
+ * Input: a map of file paths to contents (as would be read from a chart directory).
+ * The parse() method accepts the contents as a JSON-encoded map.
+ */
+export class HelmParser {
+    parse(content) {
+        // Content is a JSON map of { "path": "content" }
+        const files = JSON.parse(content);
+        return this.parseFiles(files);
+    }
+    parseFiles(files) {
+        const resources = [];
+        const parameters = [];
+        // Parse Chart.yaml
+        const chartYaml = files["Chart.yaml"];
+        if (chartYaml) {
+            const chartData = parseYAML(chartYaml);
+            resources.push({
+                logicalId: "chart",
+                type: "Helm::Chart",
+                properties: chartData,
+                metadata: { file: "Chart.yaml" },
+            });
+        }
+        // Parse values.yaml → extract parameters
+        const valuesYaml = files["values.yaml"];
+        if (valuesYaml) {
+            const valuesData = parseYAML(valuesYaml);
+            if (valuesData && typeof valuesData === "object") {
+                resources.push({
+                    logicalId: "valuesSchema",
+                    type: "Helm::Values",
+                    properties: valuesData,
+                    metadata: { file: "values.yaml" },
+                });
+                // Flatten values into parameters
+                this.extractParameters(valuesData, "", parameters);
+            }
+        }
+        // Parse templates
+        for (const [path, content] of Object.entries(files)) {
+            if (!path.startsWith("templates/"))
+                continue;
+            if (path.endsWith("_helpers.tpl"))
+                continue;
+            if (path.endsWith("NOTES.txt")) {
+                resources.push({
+                    logicalId: "notes",
+                    type: "Helm::Notes",
+                    properties: { content },
+                    metadata: { file: path },
+                });
+                continue;
+            }
+            this.parseTemplate(path, content, resources);
+        }
+        return {
+            resources,
+            parameters,
+            metadata: {
+                chartName: resources.find((r) => r.type === "Helm::Chart")?.properties?.name ?? "unknown",
+            },
+        };
+    }
+    parseTemplate(path, content, resources) {
+        const stripped = stripTemplateExpressions(content);
+        const parsed = parseYAML(stripped.yaml);
+        if (!parsed || typeof parsed !== "object")
+            return;
+        const doc = parsed;
+        const apiVersion = doc.apiVersion;
+        const kind = doc.kind;
+        if (!apiVersion || !kind)
+            return;
+        // Derive a logical ID from the file path
+        const fileName = path.replace("templates/", "").replace(/\.yaml$/, "").replace(/[/\\-]/g, "_");
+        const logicalId = kind.charAt(0).toLowerCase() + kind.slice(1) + capitalize(fileName);
+        // Restore template expressions as metadata
+        const templateExpressions = {};
+        for (const [placeholder, expr] of stripped.expressions) {
+            templateExpressions[placeholder] = {
+                expression: expr.expression,
+                kind: classifyExpression(expr.expression),
+            };
+        }
+        // Extract properties (skip apiVersion/kind)
+        const properties = {};
+        for (const [key, value] of Object.entries(doc)) {
+            if (key === "apiVersion" || key === "kind")
+                continue;
+            properties[key] = value;
+        }
+        resources.push({
+            logicalId,
+            type: `K8s::${resolveGroup(apiVersion)}::${kind}`,
+            properties,
+            metadata: {
+                file: path,
+                apiVersion,
+                kind,
+                templateExpressions,
+                blockDirectives: stripped.blockDirectives,
+            },
+        });
+    }
+    extractParameters(obj, prefix, params) {
+        for (const [key, value] of Object.entries(obj)) {
+            const fullPath = prefix ? `${prefix}.${key}` : key;
+            if (value && typeof value === "object" && !Array.isArray(value)) {
+                this.extractParameters(value, fullPath, params);
+            }
+            else {
+                params.push({
+                    name: fullPath,
+                    type: Array.isArray(value) ? "array" : typeof value,
+                    defaultValue: value,
+                });
+            }
+        }
+    }
+}
+function resolveGroup(apiVersion) {
+    if (!apiVersion.includes("/"))
+        return "Core";
+    const group = apiVersion.split("/")[0].split(".")[0];
+    return group.charAt(0).toUpperCase() + group.slice(1);
+}
+function capitalize(s) {
+    return s.split(/[_-]/).map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+}

package/dist/import/template-stripper.js

@@ -0,0 +1,86 @@
+/**
+ * Go template expression extraction and stripping.
+ *
+ * Strips Go template expressions (`{{ ... }}`) from Helm templates,
+ * replacing them with placeholder values so the underlying YAML can be parsed.
+ * Records the original expressions for later reconstruction as Helm intrinsics.
+ */
+/**
+ * Strip Go template expressions from a Helm template file.
+ *
+ * - Inline expressions (`{{ .Values.x }}`) are replaced with `__HELM_PLACEHOLDERn__`
+ * - Block-level directives (`{{- if ... }}`, `{{- end }}`, `{{- range ... }}`) are removed
+ * - Action pipelines are preserved in the expression map
+ */
+export function stripTemplateExpressions(template) {
+    const expressions = new Map();
+    const blockDirectives = [];
+    let counter = 0;
+    const lines = template.split("\n");
+    const outputLines = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const lineNum = i + 1;
+        // Check if this is a standalone block directive line
+        const trimmed = line.trim();
+        if (isBlockDirectiveLine(trimmed)) {
+            blockDirectives.push({ directive: trimmed, line: lineNum });
+            continue; // Remove entire line
+        }
+        // Replace inline expressions with placeholders
+        const processed = line.replace(/\{\{-?\s*(.*?)\s*-?\}\}/g, (_match, expr) => {
+            const placeholder = `__HELM_PLACEHOLDER${counter}__`;
+            counter++;
+            expressions.set(placeholder, { placeholder, expression: expr.trim(), line: lineNum });
+            return placeholder;
+        });
+        outputLines.push(processed);
+    }
+    return {
+        yaml: outputLines.join("\n"),
+        expressions,
+        blockDirectives,
+    };
+}
+/**
+ * Check if a line is a standalone block directive (if/else/end/range/with/define/block).
+ */
+function isBlockDirectiveLine(trimmed) {
+    if (!trimmed.startsWith("{{"))
+        return false;
+    // Extract the directive content
+    const match = trimmed.match(/^\{\{-?\s*(if|else|else if|end|range|with|define|block|template)\b/);
+    if (!match)
+        return false;
+    // Verify the line is ONLY the directive (not mixed with YAML)
+    // A standalone directive line starts with {{ and ends with }}
+    return /\}\}\s*$/.test(trimmed);
+}
+export function classifyExpression(expr) {
+    const trimmed = expr.trim();
+    if (trimmed.startsWith("include "))
+        return "include";
+    if (trimmed.startsWith("toYaml ") || trimmed.includes("| toYaml"))
+        return "toYaml";
+    if (trimmed.startsWith("required "))
+        return "required";
+    if (trimmed.startsWith("default "))
+        return "default";
+    if (trimmed.startsWith("printf "))
+        return "printf";
+    if (trimmed.startsWith("lookup "))
+        return "lookup";
+    if (trimmed.startsWith("tpl "))
+        return "tpl";
+    if (trimmed.includes("| quote"))
+        return "quote";
+    if (trimmed.includes("|"))
+        return "pipe";
+    if (trimmed.startsWith(".Values."))
+        return "values";
+    if (trimmed.startsWith(".Release."))
+        return "release";
+    if (trimmed.startsWith(".Chart."))
+        return "chart";
+    return "other";
+}

package/dist/index.js

@@ -0,0 +1,55 @@
+// Serializer
+export { helmSerializer } from "./serializer.js";
+// Plugin
+export { helmPlugin } from "./plugin.js";
+// #1495 piece 4 — the component surface. `helmCapabilityPlugin` exported from
+// the package entry is what `loadCapabilityPluginFromLexicon` scans for, the
+// same discovery the aws and k8s plugins ride.
+export { helmCapabilityPlugin, HELM_VERB_FAMILIES } from "./components/capability-plugin.js";
+export { helmUpgradeCapability, createHelmUpgradeCapability } from "./components/helm-upgrade.js";
+// Typed Op step-builder wrappers (chant #1288 Stage 2) — helmInstall/
+// helmInstallPinned with authoring-time types derived from this lexicon's
+// own HelmInstallArgs (see ./op/builders.ts's module doc for why these live
+// here rather than in core). Opt-in: `@intentius/chant/op`'s same-named
+// exports are core's original untyped builders, unchanged, for
+// cloud-agnostic authoring.
+export { helmInstall, helmInstallPinned } from "./op/builders.js";
+// Resources
+export { Chart, Values, ValuesOverride, HelmTest, HelmNotes, HelmHook, HelmDependency, HelmMaintainer, HelmCRD } from "./resources.js";
+// HelmRender — render an upstream chart at chant build time
+export { HelmRender, getHelmRenderRecords, clearHelmRenderRecords } from "./render.js";
+// #1237 — render canonicalization + the contentDigest/inputDigest split.
+export { canonicalizeRender, helmContentDigest, helmInputDigest, renderStability } from "./render-digest.js";
+// #1238 — RenderManifest + content-addressed render storage.
+export { helmValuesDigest, indexRenderDocuments, renderCacheKey, renderStoreRoot, persistHelmRender, loadRenderManifest, loadRenderContent, listRenderManifests, findRenderByCacheKey, readRenderDocument, } from "./render-store.js";
+// #1239 — structure-preserving render wrapper: segment-based CRD routing.
+export { routeRender, routeStoredRender } from "./render-wrapper.js";
+// #1242 — pinned install path: wrapper-chart materialization.
+export { materializeWrapperChart, wrapperChartName } from "./wrapper-chart.js";
+// #1240 — addArchiveHelmRender: fold a pinned render into a build archive.
+export { addArchiveHelmRender, HELM_RENDER_MEDIA_TYPE } from "./archive-render.js";
+// #1251/#1252 — build-time coalesced-values probe and its provenance products.
+export { probeCoalescedValues, coalescedValuesDigest, computeValueSources, findDeadAssignments, rootCoalescedValues, getValuesProbeRecords, recordValuesProbe, clearValuesProbeRecords, } from "./values-probe.js";
+// Capability profiles — per-cluster render inputs (#1235, epic #1228)
+export { helmConfigSchema, helmCapabilityProfileSchema, resolveCapabilityProfile, validateCapabilityProfile, KUBE_VERSION_PATTERN, } from "./config.js";
+// Intrinsics
+export { HelmTpl, HELM_TPL_KEY, HELM_IF_KEY, HELM_RANGE_KEY, HELM_WITH_KEY, RuntimeSlot, RUNTIME_SLOT_KEY, runtimeSlot, values, Release, ChartRef, include, required, helmDefault, toYaml, quote, printf, tpl, lookup, Capabilities, Template, filesGet, filesGlob, filesAsConfig, filesAsSecrets, ElseIf, If, Range, With, withOrder, argoWave, } from "./intrinsics.js";
+// Helpers
+export { generateHelpers } from "./helpers.js";
+// Code generation pipeline
+export { generate, writeGeneratedFiles } from "./codegen/generate.js";
+export { packageLexicon } from "./codegen/package.js";
+// Composites
+export { HelmWebApp, HelmStatefulService, HelmCronJob, HelmMicroservice, HelmLibrary, HelmCRDLifecycle, HelmDaemonSet, HelmWorker, HelmExternalSecret, HelmBatchJob, HelmMonitoredService, HelmSecureIngress, HelmNamespaceEnv, } from "./composites/index.js";
+// Import pipeline
+export { HelmParser } from "./import/parser.js";
+export { HelmGenerator } from "./import/generator.js";
+export { stripTemplateExpressions, classifyExpression } from "./import/template-stripper.js";
+// Pinnability gate (#1234, epic #1228) — what the pinned-render pipeline
+// consults before anything is pinned
+export { classifyChart } from "./pinnability/index.js";
+// LSP providers
+export { helmCompletions } from "./lsp/completions.js";
+export { helmHover } from "./lsp/hover.js";
+// Docs generation
+export { generateDocs } from "./codegen/docs.js";

package/dist/integrity.json

@@ -1,7 +1,7 @@
 {
   "algorithm": "sha256",
   "artifacts": {
-    "manifest.json": "8d31257cc1103f2237d70f3954e8d754bf6e6303fcda9ea5777ba2c5984ac537",
+    "manifest.json": "835f8c4a69d90939bbbf73aa3675fa83ee0950d45455d0b2c80144391265270d",
     "meta.json": "14243c5730a07c6a6edc35ddd351438547d58df5cf345f2233a355b0c7611ccc",
     "types/index.d.ts": "5377696ca8698cd2999e4680feb8e8e4b54a7b49fb603a87b2f27356114d1794",
     "rules/chart-metadata.ts": "3ac9183a3bd42c657d1c4b7e45ddb302a75baf126d62284fa9d6f6226c2734cc",
@@ -36,5 +36,5 @@
     "skills/chant-helm-patterns.md": "9e79e6a46391da46709d8aa57e2825a7cd9eb981cd923f02ad60836c49b2561e",
     "skills/chant-helm-security.md": "bfc367eabceed2e84f1cf94501b407df78aeed963cec104f24a321d0962063c9"
   },
-  "composite": "2464d9b2fe2c252c6333c4bedbf4a58439160f31f3377b92a4631a109c9320df"
+  "composite": "f261b893751784a0ec7ef517cad0deea10301b7dfbd95ce837e73c04454def0b"
 }