Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
feat(deploy): render Helm images, mark default-valued images, link crds and werf charts
Martin Vogeld21949ef2c22
diff --git a/Makefile.cbm b/Makefile.cbmindex b4b8c8827..1e3055874 100644--- a/Makefile.cbm+++ b/Makefile.cbm@@ -537,6 +537,7 @@ PIPELINE_SRCS = \src/pipeline/pass_compile_commands.c \src/pipeline/pass_infrascan.c \src/pipeline/pass_k8s.c \+ src/pipeline/helm_template.c \src/pipeline/pass_operator.c \src/pipeline/pass_shell.c \src/pipeline/pass_terraform.c \diff --git a/internal/cbm/cbm.h b/internal/cbm/cbm.hindex 86586dd15..103cc0cde 100644--- a/internal/cbm/cbm.h+++ b/internal/cbm/cbm.h@@ -719,7 +719,9 @@ typedef struct {* from the URL `name`; a HelmRelease whose chartRef names it deploys the* chart there.* CBM_K8S_FACT_IMAGE: object def_index runs its container `container`- * (NULL: unnamed) from image `name` (a literal reference); via "container".+ * (NULL: unnamed) from image `name` (a literal reference, or a Helm+ * template's placeholder `<...>`, which names none); via "container";+ * `line` the image's line, start_line / end_line the container's.* CBM_K8S_FACT_ENV: object def_index sets environment variable `name` in* its container `container` (NULL: unnamed) at `line`; via = where the* value comes from ("value", or the valueFrom kind) -- never the value.@@ -758,6 +760,8 @@ typedef struct {const char *url; /* DEPLOY (kustomize): the chart repository */const char *release; /* DEPLOY (kustomize): the release name */int line;+ int start_line; /* IMAGE: the container mapping's first line */+ int end_line; /* IMAGE: its last line */} CBMK8sFact;typedef struct {diff --git a/internal/cbm/extract_k8s.c b/internal/cbm/extract_k8s.cindex a3572763e..ce41a5690 100644--- a/internal/cbm/extract_k8s.c+++ b/internal/cbm/extract_k8s.c@@ -1487,12 +1487,18 @@ static void k8s_container(k8s_walk_t *w, const char *path, TSNode container) {const char *cname = k8s_text(w, container, "name");cname = cname && cname[0] && !strstr(cname, "{{") ? cname : NULL;const char *image = k8s_text(w, container, "image");- if (k8s_image_literal(image)) {+ /* a Helm template's image is its skeleton placeholder: pass_k8s.c renders it */+ if (k8s_image_literal(image) || (image && strchr(image, '<'))) {+ TSNode iv = k8s_child(w, container, "image");CBMK8sFact f = {.fact = CBM_K8S_FACT_IMAGE,.def_index = w->def_index,.name = image,.container = cname,- .via = "container"};+ .via = "container",+ .line =+ ts_node_is_null(iv) ? 0 : (int)ts_node_start_point(iv).row + SKIP_ONE,+ .start_line = (int)ts_node_start_point(container).row + SKIP_ONE,+ .end_line = (int)ts_node_end_point(container).row + SKIP_ONE};cbm_k8sfact_push(&w->ctx->result->k8s_facts, w->ctx->arena, f);}k8s_iter_t env = k8s_iter(k8s_child(w, container, "env"));diff --git a/src/pipeline/helm_template.c b/src/pipeline/helm_template.cnew file mode 100644index 000000000..79293e638--- /dev/null+++ b/src/pipeline/helm_template.c@@ -0,0 +1,2912 @@+/*+ * helm_template.c -- Helm values and the rendering of a chart template's+ * image references (see helm_template.h).+ *+ * Values: YAML -> JSON as Helm does it (sigs.k8s.io/yaml over go-yaml v2):+ * YAML 1.1 booleans (yes/no/on/off), `~` / null / empty a null, every number+ * a float64 -- a float prints like Go's %v (1.10 -> 1.1, 20231010 ->+ * 2.023101e+07), the way Helm renders it. --set values keep int64.+ *+ * Rendering: Go text/template over the vendored gotmpl grammar -- text with+ * {{- / -}} trimming; if / else if / else, with, range (lists, maps by sorted+ * key, else, break / continue), variables (:= / =, `$` the template's data),+ * define / template / block / include / tpl, pipelines (the piped value is+ * the last argument); and the Sprig functions image expressions use. A missing+ * map key renders "" (Helm drops "<no value>"); a field of nil is an error.+ * An error, a function not modelled, .Release.Name / .Capabilities / lookup,+ * a define not found -- each is UNKNOWN, which spreads to what reads it; a+ * condition or range that is UNKNOWN runs no branch. Nesting of include /+ * template stops where Helm's does (1000), an error there too.+ */+#include "pipeline/helm_template.h"++#include "foundation/constants.h"+#include "foundation/hash_table.h"+#include "foundation/json_writer.h" /* cbm_json_writer_allocator */+#include "foundation/mem_core.h"+#include "cbm.h"+#include "lang_specs.h"++#include <ctype.h>+#include <math.h>+#include <stdint.h>+#include <stdio.h>+#include <stdlib.h>+#include <string.h>++enum { HELM_MAX_NESTING = 1000 }; /* Helm engine's recursionMaxNums */++/* ── Values: YAML -> JSON ─────────────────────────────────────────── */++typedef struct {+ const char *name;+ size_t len;+ yyjson_mut_val *val;+} hy_anchor_t;++typedef struct {+ yyjson_mut_doc *doc;+ const char *src;+ hy_anchor_t *anchors;+ int nanchors;+ int cap;+ bool unknown;+} hy_t;++static bool hy_type(TSNode n, const char *t) {+ return !ts_node_is_null(n) && strcmp(ts_node_type(n), t) == 0;+}++static const char *hy_text(const hy_t *y, TSNode n, size_t *len) {+ uint32_t b = ts_node_start_byte(n);+ *len = ts_node_end_byte(n) - b;+ return y->src + b;+}++static void hy_anchor(hy_t *y, const char *name, size_t len, yyjson_mut_val *v) {+ if (y->nanchors == y->cap) {+ int cap = y->cap ? y->cap * PAIR_LEN : CBM_SZ_16;+ hy_anchor_t *g = cbm_realloc(CBM_MEM_CLASS_OTHER, y->anchors, (size_t)cap * sizeof(*g));+ if (!g) {+ y->unknown = true;+ return;+ }+ y->anchors = g;+ y->cap = cap;+ }+ y->anchors[y->nanchors++] = (hy_anchor_t){name, len, v};+}++static yyjson_mut_val *hy_alias(hy_t *y, const char *name, size_t len) {+ for (int i = y->nanchors - SKIP_ONE; i >= 0; i--) {+ if (y->anchors[i].len == len && memcmp(y->anchors[i].name, name, len) == 0) {+ return yyjson_mut_val_mut_copy(y->doc, y->anchors[i].val);+ }+ }+ y->unknown = true;+ return NULL;+}++static bool hy_in(const char *s, size_t n, const char *const *set) {+ for (; *set; set++) {+ if (strlen(*set) == n && memcmp(*set, s, n) == 0) {+ return true;+ }+ }+ return false;+}++/* A float of go-yaml v2's form: [-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)? */+static bool hy_float_form(const char *s, size_t n) {+ size_t i = 0;+ if (i < n && (s[i] == '-' || s[i] == '+')) {+ i++;+ }+ size_t digits = 0;+ while (i < n && isdigit((unsigned char)s[i])) {+ i++;+ digits++;+ }+ if (i < n && s[i] == '.') {+ i++;+ size_t frac = 0;+ while (i < n && isdigit((unsigned char)s[i])) {+ i++;+ frac++;+ }+ if (digits == 0 && frac == 0) {+ return false;+ }+ } else if (digits == 0) {+ return false;+ }+ if (i < n && (s[i] == 'e' || s[i] == 'E')) {+ i++;+ if (i < n && (s[i] == '-' || s[i] == '+')) {+ i++;+ }+ size_t ed = 0;+ while (i < n && isdigit((unsigned char)s[i])) {+ i++;+ ed++;+ }+ if (ed == 0) {+ return false;+ }+ }+ return i == n;+}++/* An integer the way go-yaml v2 reads one: strconv.ParseInt(s, 0, 64) after+ * dropping `_` -- decimal, 0x hex, 0b binary, a leading 0 octal. */+static bool hy_int_form(const char *s, size_t n, int64_t *out) {+ char buf[CBM_SZ_64];+ size_t k = 0;+ for (size_t i = 0; i < n && k + SKIP_ONE < sizeof(buf); i++) {+ if (s[i] != '_') {+ buf[k++] = s[i];+ }+ }+ if (k == 0 || k + SKIP_ONE >= sizeof(buf)) {+ return false;+ }+ buf[k] = '\0';+ const char *p = buf;+ bool neg = false;+ if (*p == '-' || *p == '+') {+ neg = *p == '-';+ p++;+ }+ int base = 10;+ if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {+ base = 16;+ p += PAIR_LEN;+ } else if (p[0] == '0' && (p[1] == 'b' || p[1] == 'B')) {+ base = 2;+ p += PAIR_LEN;+ } else if (p[0] == '0' && p[1]) {+ base = 8;+ p++;+ }+ if (!*p) {+ return false;+ }+ char *end = NULL;+ long long v = strtoll(p, &end, base);+ if (!end || *end) {+ return false;+ }+ *out = neg ? -(int64_t)v : (int64_t)v;+ return true;+}++static yyjson_mut_val *hy_plain(hy_t *y, const char *s, size_t n) {+ static const char *const NULLS[] = {"", "~", "null", "Null", "NULL", NULL};+ static const char *const TRUES[] = {"y", "Y", "yes", "Yes", "YES", "true",+ "True", "TRUE", "on", "On", "ON", NULL};+ static const char *const FALSES[] = {"n", "N", "no", "No", "NO", "false",+ "False", "FALSE", "off", "Off", "OFF", NULL};+ static const char *const SPECIAL[] = {".inf", ".Inf", ".INF", "+.inf", "+.Inf",+ "+.INF", "-.inf", "-.Inf", "-.INF", ".nan",+ ".NaN", ".NAN", NULL};+ if (hy_in(s, n, NULLS)) {+ return yyjson_mut_null(y->doc);+ }+ if (hy_in(s, n, TRUES)) {+ return yyjson_mut_true(y->doc);+ }+ if (hy_in(s, n, FALSES)) {+ return yyjson_mut_false(y->doc);+ }+ if (hy_in(s, n, SPECIAL)) {+ y->unknown = true; /* JSON holds no inf / nan: Helm fails here */+ return NULL;+ }+ char c = n ? s[0] : '\0';+ if (isdigit((unsigned char)c) || c == '-' || c == '+' || c == '.') {+ int64_t iv = 0;+ if (hy_int_form(s, n, &iv)) {+ return yyjson_mut_real(y->doc, (double)iv);+ }+ if (hy_float_form(s, n)) {+ char buf[CBM_SZ_64];+ snprintf(buf, sizeof(buf), "%.*s", (int)n, s);+ return yyjson_mut_real(y->doc, strtod(buf, NULL));+ }+ }+ return yyjson_mut_strncpy(y->doc, s, n);+}++static int hy_hex(char c) {+ if (c >= '0' && c <= '9') {+ return c - '0';+ }+ c = (char)tolower((unsigned char)c);+ return c >= 'a' && c <= 'f' ? c - 'a' + 10 : -SKIP_ONE;+}++static size_t hy_utf8(unsigned long cp, char *out) {+ if (cp < 0x80) {+ out[0] = (char)cp;+ return SKIP_ONE;+ }+ if (cp < 0x800) {+ out[0] = (char)(0xC0 | (cp >> 6));+ out[1] = (char)(0x80 | (cp & 0x3F));+ return PAIR_LEN;+ }+ if (cp < 0x10000) {+ out[0] = (char)(0xE0 | (cp >> 12));+ out[1] = (char)(0x80 | ((cp >> 6) & 0x3F));+ out[2] = (char)(0x80 | (cp & 0x3F));+ return 3;+ }+ out[0] = (char)(0xF0 | (cp >> 18));+ out[1] = (char)(0x80 | ((cp >> 12) & 0x3F));+ out[2] = (char)(0x80 | ((cp >> 6) & 0x3F));+ out[3] = (char)(0x80 | (cp & 0x3F));+ return 4;+}++/* Fold a quoted scalar's line breaks: a break and the blanks around it+ * become one space, an empty line a newline. */+static size_t hy_fold(char *buf, size_t n) {+ size_t k = 0;+ for (size_t i = 0; i < n;) {+ if (buf[i] == '\n') {+ while (k > 0 && (buf[k - SKIP_ONE] == ' ' || buf[k - SKIP_ONE] == '\t')) {+ k--;+ }+ size_t breaks = 0;+ while (i < n && (buf[i] == '\n' || buf[i] == ' ' || buf[i] == '\t' || buf[i] == '\r')) {+ breaks += buf[i] == '\n';+ i++;+ }+ if (breaks > SKIP_ONE) {+ for (size_t b = SKIP_ONE; b < breaks; b++) {+ buf[k++] = '\n';+ }+ } else {+ buf[k++] = ' ';+ }+ continue;+ }+ buf[k++] = buf[i++];+ }+ return k;+}++static yyjson_mut_val *hy_double(hy_t *y, const char *s, size_t n) {+ if (n < PAIR_LEN) {+ y->unknown = true;+ return NULL;+ }+ char *buf = cbm_alloc(CBM_MEM_CLASS_OTHER, n * 4 + SKIP_ONE);+ if (!buf) {+ y->unknown = true;+ return NULL;+ }+ size_t k = 0;+ for (size_t i = SKIP_ONE; i + SKIP_ONE < n; i++) {+ char c = s[i];+ if (c != '\\') {+ buf[k++] = c;+ continue;+ }+ if (++i + SKIP_ONE >= n + SKIP_ONE) {+ break;+ }+ c = s[i];+ static const char ESC_IN[] = "0abtnvfre \"/\\N_LP\t";+ static const char ESC_OUT[] = "\0\a\b\t\n\v\f\r\x1b \"/\\";+ const char *e = strchr(ESC_IN, c);+ if (c == '\n') {+ while (i + SKIP_ONE < n && (s[i + SKIP_ONE] == ' ' || s[i + SKIP_ONE] == '\t')) {+ i++;+ }+ } else if (e && (size_t)(e - ESC_IN) < sizeof(ESC_OUT) - SKIP_ONE) {+ buf[k++] = ESC_OUT[e - ESC_IN];+ } else if (c == 'x' || c == 'u' || c == 'U') {+ int digits = c == 'x' ? PAIR_LEN : c == 'u' ? 4 : 8;+ uint32_t cp = 0;+ for (int d = 0; d < digits; d++) {+ int h = i + SKIP_ONE < n ? hy_hex(s[i + SKIP_ONE]) : -SKIP_ONE;+ if (h < 0) {+ y->unknown = true;+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return NULL;+ }+ cp = cp * 16 + (uint32_t)h;+ i++;+ }+ k += hy_utf8(cp, buf + k);+ } else {+ y->unknown = true;+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return NULL;+ }+ }+ k = hy_fold(buf, k);+ yyjson_mut_val *v = yyjson_mut_strncpy(y->doc, buf, k);+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return v;+}++static yyjson_mut_val *hy_single(hy_t *y, const char *s, size_t n) {+ if (n < PAIR_LEN) {+ y->unknown = true;+ return NULL;+ }+ char *buf = cbm_alloc(CBM_MEM_CLASS_OTHER, n + SKIP_ONE);+ if (!buf) {+ y->unknown = true;+ return NULL;+ }+ size_t k = 0;+ for (size_t i = SKIP_ONE; i + SKIP_ONE < n; i++) {+ buf[k++] = s[i];+ if (s[i] == '\'' && i + PAIR_LEN < n && s[i + SKIP_ONE] == '\'') {+ i++;+ }+ }+ k = hy_fold(buf, k);+ yyjson_mut_val *v = yyjson_mut_strncpy(y->doc, buf, k);+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return v;+}++/* A block scalar (| or >, chomping - / +, an explicit indentation digit). */+static yyjson_mut_val *hy_block(hy_t *y, const char *s, size_t n) {+ size_t i = 0;+ bool folded = n > 0 && s[0] == '>';+ char chomp = 'c';+ int explicit_indent = 0;+ for (i = SKIP_ONE; i < n && s[i] != '\n' && s[i] != '#'; i++) {+ if (s[i] == '-' || s[i] == '+') {+ chomp = s[i];+ } else if (isdigit((unsigned char)s[i])) {+ explicit_indent = s[i] - '0';+ }+ }+ while (i < n && s[i] != '\n') {+ i++;+ }+ i += i < n ? SKIP_ONE : 0;+ /* the content's indentation: the explicit one, else its first non-empty line's */+ size_t indent = 0;+ if (explicit_indent > 0) {+ /* relative to the parent's: the line indentation of the scalar's own start */+ const char *ls = s;+ while (ls > y->src && ls[-1] != '\n') {+ ls--;+ }+ size_t parent = 0;+ while (ls + parent < s && ls[parent] == ' ') {+ parent++;+ }+ indent = parent + (size_t)explicit_indent;+ } else {+ for (size_t j = i; j < n;) {+ size_t sp = 0;+ while (j + sp < n && s[j + sp] == ' ') {+ sp++;+ }+ if (j + sp < n && s[j + sp] != '\n') {+ indent = sp;+ break;+ }+ j += sp + SKIP_ONE;+ }+ }+ char *buf = cbm_alloc(CBM_MEM_CLASS_OTHER, n + PAIR_LEN);+ if (!buf) {+ y->unknown = true;+ return NULL;+ }+ size_t k = 0;+ bool prev_more = false; /* the previous line was more indented (folded keeps its break) */+ bool first = true;+ while (i < n) {+ size_t sp = 0;+ while (i + sp < n && s[i + sp] == ' ' && sp < indent) {+ sp++;+ }+ size_t e = i + sp;+ while (e < n && s[e] != '\n') {+ e++;+ }+ bool empty = e == i + sp;+ bool more = !empty && (s[i + sp] == ' ' || s[i + sp] == '\t');+ if (folded && !first && k > 0 && buf[k - SKIP_ONE] == '\n' && !empty && !more &&+ !prev_more) {+ /* a break between two plain lines folds into a space ... */+ size_t back = k - SKIP_ONE;+ bool only = back == 0 || buf[back - SKIP_ONE] != '\n';+ if (only) {+ buf[back] = ' ';+ } else {+ /* ... one of several breaks is dropped */+ k = back;+ }+ }+ memcpy(buf + k, s + i + sp, e - (i + sp));+ k += e - (i + sp);+ buf[k++] = '\n';+ prev_more = more;+ first = empty && first;+ i = e + SKIP_ONE;+ }+ if (chomp != '+') {+ while (k > 0 && buf[k - SKIP_ONE] == '\n') {+ k--;+ }+ if (chomp == 'c' && k > 0) {+ buf[k++] = '\n';+ }+ }+ yyjson_mut_val *v = yyjson_mut_strncpy(y->doc, buf, k);+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return v;+}++static yyjson_mut_val *hy_node(hy_t *y, TSNode n);++/* A mapping key as JSON: its scalar's text (sigs.k8s.io/yaml stringifies). */+static yyjson_mut_val *hy_key(hy_t *y, TSNode k) {+ yyjson_mut_val *v = ts_node_is_null(k) ? yyjson_mut_null(y->doc) : hy_node(y, k);+ if (!v) {+ return NULL;+ }+ if (yyjson_mut_is_str(v)) {+ return v;+ }+ if (yyjson_mut_is_null(v)) {+ return yyjson_mut_strcpy(y->doc, "null");+ }+ if (yyjson_mut_is_bool(v)) {+ return yyjson_mut_strcpy(y->doc, yyjson_mut_get_bool(v) ? "true" : "false");+ }+ if (yyjson_mut_is_real(v)) {+ /* go-yaml v2 keeps an integer key an int: its decimal digits */+ double d = yyjson_mut_get_real(v);+ char buf[CBM_SZ_64];+ if (d == floor(d) && fabs(d) < 1e18) {+ snprintf(buf, sizeof(buf), "%lld", (long long)d);+ } else {+ snprintf(buf, sizeof(buf), "%.17g", d);+ }+ return yyjson_mut_strcpy(y->doc, buf);+ }+ y->unknown = true; /* a mapping / sequence as a key */+ return NULL;+}++/* YAML merge key: `<<: *a` / `<<: [*a, *b]` -- entries not already there. */+static void hy_merge(yyjson_mut_val *obj, yyjson_mut_val *src) {+ if (yyjson_mut_is_arr(src)) {+ size_t idx, max;+ yyjson_mut_val *it;+ yyjson_mut_arr_foreach(src, idx, max, it) {+ hy_merge(obj, it);+ }+ return;+ }+ if (!yyjson_mut_is_obj(src)) {+ return;+ }+ size_t idx, max;+ yyjson_mut_val *k, *v;+ yyjson_mut_obj_foreach(src, idx, max, k, v) {+ if (!yyjson_mut_obj_getn(obj, yyjson_mut_get_str(k), yyjson_mut_get_len(k))) {+ yyjson_mut_obj_add(obj, k, v);+ }+ }+}++static yyjson_mut_val *hy_mapping(hy_t *y, TSNode n, const char *pair_type) {+ yyjson_mut_val *obj = yyjson_mut_obj(y->doc);+ yyjson_mut_val *merges = NULL;+ for (uint32_t i = 0; obj && i < ts_node_named_child_count(n); i++) {+ TSNode p = ts_node_named_child(n, i);+ if (hy_type(p, "comment")) {+ continue;+ }+ TSNode kn = p;+ TSNode vn = {0};+ if (hy_type(p, pair_type)) {+ kn = ts_node_child_by_field_name(p, "key", (uint32_t)strlen("key"));+ vn = ts_node_child_by_field_name(p, "value", (uint32_t)strlen("value"));+ } else if (!hy_type(p, "flow_node")) {+ y->unknown = true;+ return NULL;+ }+ size_t kl = 0;+ const char *kt = ts_node_is_null(kn) ? "" : hy_text(y, kn, &kl);+ yyjson_mut_val *val = ts_node_is_null(vn) ? yyjson_mut_null(y->doc) : hy_node(y, vn);+ if (!val || y->unknown) {+ y->unknown = true;+ return NULL;+ }+ if (kl == PAIR_LEN && memcmp(kt, "<<", PAIR_LEN) == 0) {+ merges = merges ? merges : yyjson_mut_arr(y->doc);+ yyjson_mut_arr_append(merges, val);+ continue;+ }+ yyjson_mut_val *key = hy_key(y, kn);+ if (!key) {+ y->unknown = true;+ return NULL;+ }+ (void)yyjson_mut_obj_put(obj, key, val); /* a duplicate key: the last one */+ }+ if (obj && merges) {+ hy_merge(obj, merges);+ }+ return obj;+}++static yyjson_mut_val *hy_sequence(hy_t *y, TSNode n) {+ yyjson_mut_val *arr = yyjson_mut_arr(y->doc);+ for (uint32_t i = 0; arr && i < ts_node_named_child_count(n); i++) {+ TSNode it = ts_node_named_child(n, i);+ if (hy_type(it, "comment")) {+ continue;+ }+ TSNode content = it;+ if (hy_type(it, "block_sequence_item")) {+ content = ts_node_named_child_count(it) > 0 ? ts_node_named_child(it, 0) : (TSNode){0};+ while (!ts_node_is_null(content) && hy_type(content, "comment")) {+ content = ts_node_next_named_sibling(content);+ }+ }+ yyjson_mut_val *v = ts_node_is_null(content) ? yyjson_mut_null(y->doc)+ : hy_type(content, "flow_pair") ? NULL+ : hy_node(y, content);+ if (hy_type(content, "flow_pair")) {+ /* [a: b] -- a single-pair map */+ v = yyjson_mut_obj(y->doc);+ TSNode kn = ts_node_child_by_field_name(content, "key", (uint32_t)strlen("key"));+ TSNode vn = ts_node_child_by_field_name(content, "value", (uint32_t)strlen("value"));+ yyjson_mut_val *key = hy_key(y, kn);+ yyjson_mut_val *val = ts_node_is_null(vn) ? yyjson_mut_null(y->doc) : hy_node(y, vn);+ if (!key || !val) {+ y->unknown = true;+ return NULL;+ }+ yyjson_mut_obj_add(v, key, val);+ }+ if (!v || y->unknown) {+ y->unknown = true;+ return NULL;+ }+ yyjson_mut_arr_append(arr, v);+ }+ return arr;+}++static yyjson_mut_val *hy_node(hy_t *y, TSNode n) {+ if (ts_node_is_null(n) || ts_node_has_error(n) || y->unknown) {+ y->unknown = true;+ return NULL;+ }+ const char *t = ts_node_type(n);+ if (strcmp(t, "block_node") == 0 || strcmp(t, "flow_node") == 0) {+ TSNode content = {0};+ const char *anchor = NULL;+ size_t al = 0;+ bool str_tag = false;+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ if (hy_type(c, "anchor")) {+ TSNode nm = ts_node_named_child(c, 0);+ anchor = ts_node_is_null(nm) ? NULL : hy_text(y, nm, &al);+ } else if (hy_type(c, "tag")) {+ size_t tl = 0;+ const char *tt = hy_text(y, c, &tl);+ str_tag = tl == strlen("!!str") && memcmp(tt, "!!str", tl) == 0;+ } else if (!hy_type(c, "comment")) {+ content = c;+ }+ }+ yyjson_mut_val *v = NULL;+ if (ts_node_is_null(content)) {+ v = yyjson_mut_null(y->doc);+ } else if (str_tag && hy_type(content, "plain_scalar")) {+ size_t l = 0;+ const char *s = hy_text(y, content, &l);+ v = yyjson_mut_strncpy(y->doc, s, l);+ } else {+ v = hy_node(y, content);+ }+ if (v && anchor) {+ hy_anchor(y, anchor, al, v);+ }+ return v;+ }+ size_t l = 0;+ const char *s = hy_text(y, n, &l);+ if (strcmp(t, "block_mapping") == 0) {+ return hy_mapping(y, n, "block_mapping_pair");+ }+ if (strcmp(t, "flow_mapping") == 0) {+ return hy_mapping(y, n, "flow_pair");+ }+ if (strcmp(t, "block_sequence") == 0 || strcmp(t, "flow_sequence") == 0) {+ return hy_sequence(y, n);+ }+ if (strcmp(t, "plain_scalar") == 0) {+ return hy_plain(y, s, l);+ }+ if (strcmp(t, "double_quote_scalar") == 0) {+ return hy_double(y, s, l);+ }+ if (strcmp(t, "single_quote_scalar") == 0) {+ return hy_single(y, s, l);+ }+ if (strcmp(t, "block_scalar") == 0) {+ return hy_block(y, s, l);+ }+ if (strcmp(t, "alias") == 0) {+ TSNode nm = ts_node_named_child(n, 0);+ size_t nl = 0;+ const char *name = ts_node_is_null(nm) ? NULL : hy_text(y, nm, &nl);+ return name ? hy_alias(y, name, nl) : NULL;+ }+ y->unknown = true;+ return NULL;+}++static void hy_done(hy_t *y) {+ cbm_free(CBM_MEM_CLASS_OTHER, y->anchors);+ y->anchors = NULL;+}++yyjson_mut_val *cbm_helm_values_node(yyjson_mut_doc *doc, const char *src, TSNode node) {+ hy_t y = {.doc = doc, .src = src};+ yyjson_mut_val *v = hy_node(&y, node);+ hy_done(&y);+ return y.unknown ? NULL : v;+}++yyjson_mut_val *cbm_helm_values_parse(yyjson_mut_doc *doc, const char *src, size_t len) {+ TSParser *parser = ts_parser_new();+ if (!parser || !ts_parser_set_language(parser, cbm_ts_language(CBM_LANG_YAML))) {+ if (parser) {+ ts_parser_delete(parser);+ }+ return NULL;+ }+ TSTree *tree = ts_parser_parse_string(parser, NULL, src, (uint32_t)len);+ yyjson_mut_val *out = NULL;+ if (tree) {+ TSNode root = ts_tree_root_node(tree);+ TSNode docn = {0};+ for (uint32_t i = 0; i < ts_node_named_child_count(root); i++) {+ if (hy_type(ts_node_named_child(root, i), "document")) {+ docn = ts_node_named_child(root, i);+ break;+ }+ }+ TSNode content = {0};+ for (uint32_t i = 0; !ts_node_is_null(docn) && i < ts_node_named_child_count(docn); i++) {+ TSNode c = ts_node_named_child(docn, i);+ if (!hy_type(c, "comment")) {+ content = c;+ break;+ }+ }+ if (ts_node_has_error(root) && (ts_node_is_null(docn) || ts_node_has_error(docn))) {+ out = NULL;+ } else if (ts_node_is_null(content)) {+ out = yyjson_mut_obj(doc);+ } else {+ out = cbm_helm_values_node(doc, src, content);+ if (out && yyjson_mut_is_null(out)) {+ out = yyjson_mut_obj(doc);+ }+ }+ ts_tree_delete(tree);+ }+ ts_parser_delete(parser);+ return out;+}++static yyjson_mut_val *hc_merge(yyjson_mut_doc *doc, yyjson_mut_val *dst, yyjson_mut_val *over) {+ if (!yyjson_mut_is_obj(dst) || !yyjson_mut_is_obj(over)) {+ return over ? yyjson_mut_val_mut_copy(doc, over) : dst;+ }+ size_t idx, max;+ yyjson_mut_val *k, *v;+ yyjson_mut_obj_foreach(over, idx, max, k, v) {+ const char *ks = yyjson_mut_get_str(k);+ size_t kl = yyjson_mut_get_len(k);+ if (yyjson_mut_is_null(v)) {+ (void)yyjson_mut_obj_remove_keyn(dst, ks, kl);+ continue;+ }+ yyjson_mut_val *cur = yyjson_mut_obj_getn(dst, ks, kl);+ yyjson_mut_val *merged = cur && yyjson_mut_is_obj(cur) && yyjson_mut_is_obj(v)+ ? hc_merge(doc, cur, v)+ : yyjson_mut_val_mut_copy(doc, v);+ if (merged != cur) {+ (void)yyjson_mut_obj_remove_keyn(dst, ks, kl);+ yyjson_mut_obj_add(dst, yyjson_mut_strncpy(doc, ks, kl), merged);+ }+ }+ return dst;+}++yyjson_mut_val *cbm_helm_values_coalesce(yyjson_mut_doc *doc, yyjson_mut_val *base,+ yyjson_mut_val *over) {+ yyjson_mut_val *out = base ? yyjson_mut_val_mut_copy(doc, base) : yyjson_mut_obj(doc);+ return over ? hc_merge(doc, out, over) : out;+}++/* Helm strvals' typedVal. */+static yyjson_mut_val *hs_typed(yyjson_mut_doc *doc, const char *v, bool as_string) {+ if (as_string) {+ return yyjson_mut_strcpy(doc, v);+ }+ if (strcasecmp(v, "true") == 0) {+ return yyjson_mut_true(doc);+ }+ if (strcasecmp(v, "false") == 0) {+ return yyjson_mut_false(doc);+ }+ if (strcasecmp(v, "null") == 0) {+ return yyjson_mut_null(doc);+ }+ if (strcmp(v, "0") == 0) {+ return yyjson_mut_sint(doc, 0);+ }+ if (v[0] && v[0] != '0') {+ char *end = NULL;+ long long iv = strtoll(v, &end, 10);+ if (end && !*end && (isdigit((unsigned char)v[0]) || v[0] == '-' || v[0] == '+')) {+ return yyjson_mut_sint(doc, iv);+ }+ }+ return yyjson_mut_strcpy(doc, v);+}++bool cbm_helm_values_set(yyjson_mut_doc *doc, yyjson_mut_val *root, const char *name,+ const char *value, bool as_string) {+ if (!yyjson_mut_is_obj(root) || !name || !name[0] || !value) {+ return false;+ }+ yyjson_mut_val *cur = root;+ const char *p = name;+ char key[CBM_SZ_512];+ while (*p) {+ size_t k = 0;+ while (*p && *p != '.' && *p != '[' && k + SKIP_ONE < sizeof(key)) {+ if (*p == '\\' && p[1]) {+ p++;+ }+ key[k++] = *p++;+ }+ key[k] = '\0';+ long index = -SKIP_ONE;+ if (*p == '[') {+ char *end = NULL;+ index = strtol(p + SKIP_ONE, &end, 10);+ if (!end || *end != ']' || index < 0) {+ return false;+ }+ p = end + SKIP_ONE;+ }+ bool last = !*p || (*p == '.' && !p[1]);+ if (*p == '.') {+ p++;+ }+ if (k == 0 || !yyjson_mut_is_obj(cur)) {+ return false;+ }+ yyjson_mut_val *child = yyjson_mut_obj_get(cur, key);+ if (index >= 0) {+ if (!yyjson_mut_is_arr(child)) {+ child = yyjson_mut_arr(doc);+ (void)yyjson_mut_obj_remove_key(cur, key);+ yyjson_mut_obj_add(cur, yyjson_mut_strcpy(doc, key), child);+ }+ while (yyjson_mut_arr_size(child) <= (size_t)index) {+ yyjson_mut_arr_append(child, yyjson_mut_null(doc));+ }+ if (last) {+ (void)yyjson_mut_arr_replace(child, (size_t)index, hs_typed(doc, value, as_string));+ return true;+ }+ yyjson_mut_val *el = yyjson_mut_arr_get(child, (size_t)index);+ if (!yyjson_mut_is_obj(el)) {+ el = yyjson_mut_obj(doc);+ (void)yyjson_mut_arr_replace(child, (size_t)index, el);+ }+ cur = el;+ continue;+ }+ if (last) {+ (void)yyjson_mut_obj_remove_key(cur, key);+ yyjson_mut_obj_add(cur, yyjson_mut_strcpy(doc, key), hs_typed(doc, value, as_string));+ return true;+ }+ if (!yyjson_mut_is_obj(child)) {+ child = yyjson_mut_obj(doc);+ (void)yyjson_mut_obj_remove_key(cur, key);+ yyjson_mut_obj_add(cur, yyjson_mut_strcpy(doc, key), child);+ }+ cur = child;+ }+ return false;+}++/* ── Defines ──────────────────────────────────────────────────────── */++typedef struct {+ char *rel;+ char *src;+ size_t len;+ TSTree *tree;+} hd_file_t;++typedef struct {+ const hd_file_t *file;+ TSNode node; /* the define_action / block_action */+ int depth;+} hd_def_t;++struct cbm_helm_defines {+ hd_file_t **files; /* each allocated once: defines point into them */+ int nfiles;+ int cap;+ CBMHashTable *names; /* name -> hd_def_t* */+};++cbm_helm_defines_t *cbm_helm_defines_new(void) {+ cbm_helm_defines_t *d = cbm_calloc(CBM_MEM_CLASS_OTHER, sizeof(*d));+ if (d) {+ d->names = cbm_ht_create(0);+ if (!d->names) {+ cbm_free(CBM_MEM_CLASS_OTHER, d);+ return NULL;+ }+ }+ return d;+}++static int hd_depth(const char *rel) {+ int n = 0;+ for (const char *p = rel; *p; p++) {+ n += *p == '/';+ }+ return n;+}++/* A Go string literal's value ("..." with escapes, `...` raw); NULL: invalid. */+static char *hg_string(const char *s, size_t n, size_t *out_len);++static void hd_scan(cbm_helm_defines_t *d, hd_file_t *f, TSNode n, int depth) {+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ const char *t = ts_node_type(c);+ bool def = strcmp(t, "define_action") == 0;+ bool block = strcmp(t, "block_action") == 0;+ if (def || block) {+ TSNode nm = ts_node_child_by_field_name(c, "name", (uint32_t)strlen("name"));+ size_t nl = 0;+ char *name = ts_node_is_null(nm)+ ? NULL+ : hg_string(f->src + ts_node_start_byte(nm),+ ts_node_end_byte(nm) - ts_node_start_byte(nm), &nl);+ if (name) {+ hd_def_t *old = cbm_ht_get(d->names, name);+ bool wins = !old || depth < old->depth ||+ (depth == old->depth && strcmp(f->rel, old->file->rel) < 0);+ hd_def_t *nd = wins ? cbm_alloc(CBM_MEM_CLASS_OTHER, sizeof(*nd)) : NULL;+ if (nd) {+ *nd = (hd_def_t){f, c, depth};+ if (old) {+ const char *key = cbm_ht_get_key(d->names, name);+ cbm_ht_set(d->names, key, nd);+ cbm_free(CBM_MEM_CLASS_OTHER, old);+ cbm_free(CBM_MEM_CLASS_OTHER, name);+ } else {+ cbm_ht_set(d->names, name, nd);+ }+ name = NULL;+ }+ cbm_free(CBM_MEM_CLASS_OTHER, name);+ }+ }+ if (block || strcmp(t, "if_action") == 0 || strcmp(t, "with_action") == 0 ||+ strcmp(t, "range_action") == 0) {+ hd_scan(d, f, c, depth); /* a define is top-level; a block nests */+ }+ }+}++void cbm_helm_defines_add(cbm_helm_defines_t *d, const char *rel, const char *src, size_t len) {+ if (!d || !src) {+ return;+ }+ if (d->nfiles == d->cap) {+ int cap = d->cap ? d->cap * PAIR_LEN : CBM_SZ_16;+ hd_file_t **g = cbm_realloc(CBM_MEM_CLASS_OTHER, d->files, (size_t)cap * sizeof(*g));+ if (!g) {+ return;+ }+ d->files = g;+ d->cap = cap;+ }+ hd_file_t *f = cbm_calloc(CBM_MEM_CLASS_OTHER, sizeof(*f));+ if (!f) {+ return;+ }+ f->rel = cbm_mem_strdup(CBM_MEM_CLASS_OTHER, rel);+ f->src = cbm_alloc(CBM_MEM_CLASS_OTHER, len + SKIP_ONE);+ if (!f->rel || !f->src) {+ cbm_free(CBM_MEM_CLASS_OTHER, f->rel);+ cbm_free(CBM_MEM_CLASS_OTHER, f->src);+ cbm_free(CBM_MEM_CLASS_OTHER, f);+ return;+ }+ memcpy(f->src, src, len);+ f->src[len] = '\0';+ f->len = len;+ TSParser *parser = ts_parser_new();+ if (parser && ts_parser_set_language(parser, cbm_ts_language(CBM_LANG_GOTEMPLATE))) {+ f->tree = ts_parser_parse_string(parser, NULL, f->src, (uint32_t)len);+ }+ if (parser) {+ ts_parser_delete(parser);+ }+ d->files[d->nfiles++] = f;+ if (f->tree) {+ hd_scan(d, f, ts_tree_root_node(f->tree), hd_depth(rel));+ }+}++static void hd_free_def(const char *key, void *value, void *ud) {+ (void)ud;+ cbm_free(CBM_MEM_CLASS_OTHER, (void *)key);+ cbm_free(CBM_MEM_CLASS_OTHER, value);+}++void cbm_helm_defines_free(cbm_helm_defines_t *d) {+ if (!d) {+ return;+ }+ if (d->names) {+ cbm_ht_foreach(d->names, hd_free_def, NULL);+ cbm_ht_free(d->names);+ }+ for (int i = 0; i < d->nfiles; i++) {+ if (d->files[i]->tree) {+ ts_tree_delete(d->files[i]->tree);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, d->files[i]->rel);+ cbm_free(CBM_MEM_CLASS_OTHER, d->files[i]->src);+ cbm_free(CBM_MEM_CLASS_OTHER, d->files[i]);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, d->files);+ cbm_free(CBM_MEM_CLASS_OTHER, d);+}++static const hd_def_t *hd_find(const cbm_helm_defines_t *d, const char *name) {+ return d && d->names ? cbm_ht_get(d->names, name) : NULL;+}++/* ── Go literals and formatting ───────────────────────────────────── */++/* The value of Go string literal s ("..." or `...`) into out (capacity n);+ * its length, or (size_t)-1 when it is no valid literal. */+static size_t hg_unquote(const char *s, size_t n, char *out) {+ if (n >= PAIR_LEN && s[0] == '`' && s[n - SKIP_ONE] == '`') {+ memcpy(out, s + SKIP_ONE, n - PAIR_LEN);+ return n - PAIR_LEN;+ }+ if (n < PAIR_LEN || s[0] != '"' || s[n - SKIP_ONE] != '"') {+ return (size_t)-1;+ }+ size_t k = 0;+ for (size_t i = SKIP_ONE; i + SKIP_ONE < n; i++) {+ char c = s[i];+ if (c != '\\') {+ out[k++] = c;+ continue;+ }+ if (++i + SKIP_ONE >= n) {+ return (size_t)-1;+ }+ c = s[i];+ static const char IN[] = "abfnrtv\\\"'";+ static const char OUT[] = "\a\b\f\n\r\t\v\\\"'";+ const char *e = strchr(IN, c);+ if (e && c) {+ out[k++] = OUT[e - IN];+ } else if (c == 'x' || c == 'u' || c == 'U') {+ int digits = c == 'x' ? PAIR_LEN : c == 'u' ? 4 : 8;+ uint32_t cp = 0;+ for (int d = 0; d < digits; d++) {+ int h = i + SKIP_ONE + SKIP_ONE < n ? hy_hex(s[i + SKIP_ONE]) : -SKIP_ONE;+ if (h < 0) {+ return (size_t)-1;+ }+ cp = cp * 16 + (uint32_t)h;+ i++;+ }+ if (c == 'x') {+ out[k++] = (char)cp;+ } else {+ k += hy_utf8(cp, out + k);+ }+ } else if (c >= '0' && c <= '7') {+ uint32_t v = 0;+ for (int d = 0; d < 3 && i + SKIP_ONE < n && s[i] >= '0' && s[i] <= '7'; d++, i++) {+ v = v * 8 + (uint32_t)(s[i] - '0');+ }+ i--;+ out[k++] = (char)v;+ } else {+ return (size_t)-1;+ }+ }+ return k;+}++static char *hg_string(const char *s, size_t n, size_t *out_len) {+ char *out = cbm_alloc(CBM_MEM_CLASS_OTHER, n * 4 + SKIP_ONE);+ if (!out) {+ return NULL;+ }+ size_t k = hg_unquote(s, n, out);+ if (k == (size_t)-1) {+ cbm_free(CBM_MEM_CLASS_OTHER, out);+ return NULL;+ }+ out[k] = '\0';+ *out_len = k;+ return out;+}++/* float64 as Go's %v writes it (strconv 'g', shortest). */+static void hg_float(double f, char *out, size_t sz) {+ if (f == 0) {+ snprintf(out, sz, signbit(f) ? "-0" : "0");+ return;+ }+ char e[CBM_SZ_64];+ int prec = 0;+ for (prec = 0; prec < 17; prec++) {+ snprintf(e, sizeof(e), "%.*e", prec, f);+ if (strtod(e, NULL) == f) {+ break;+ }+ }+ /* e: [-]d[.ddd]e(+|-)XX */+ bool neg = e[0] == '-';+ const char *p = e + (neg ? SKIP_ONE : 0);+ char digs[CBM_SZ_32];+ int nd = 0;+ for (; *p && *p != 'e'; p++) {+ if (isdigit((unsigned char)*p) && nd + SKIP_ONE < (int)sizeof(digs)) {+ digs[nd++] = *p;+ }+ }+ while (nd > SKIP_ONE && digs[nd - SKIP_ONE] == '0') {+ nd--;+ }+ digs[nd] = '\0';+ int exp = *p == 'e' ? atoi(p + SKIP_ONE) : 0;+ int dp = exp + SKIP_ONE;+ size_t k = 0;+ if (neg) {+ out[k++] = '-';+ }+ if (exp < -4 || exp >= 6) {+ out[k++] = digs[0];+ if (nd > SKIP_ONE) {+ out[k++] = '.';+ for (int i = SKIP_ONE; i < nd && k + 8 < sz; i++) {+ out[k++] = digs[i];+ }+ }+ snprintf(out + k, sz - k, "e%c%02d", exp < 0 ? '-' : '+', exp < 0 ? -exp : exp);+ return;+ }+ if (dp <= 0) {+ out[k++] = '0';+ out[k++] = '.';+ for (int i = 0; i < -dp && k + 4 < sz; i++) {+ out[k++] = '0';+ }+ for (int i = 0; i < nd && k + 4 < sz; i++) {+ out[k++] = digs[i];+ }+ } else {+ for (int i = 0; i < dp && k + 4 < sz; i++) {+ out[k++] = i < nd ? digs[i] : '0';+ }+ if (nd > dp) {+ out[k++] = '.';+ for (int i = dp; i < nd && k + 4 < sz; i++) {+ out[k++] = digs[i];+ }+ }+ }+ out[k] = '\0';+}++bool cbm_helm_scalar_text(yyjson_mut_val *v, char *out, size_t sz) {+ if (yyjson_mut_is_str(v)) {+ snprintf(out, sz, "%s", yyjson_mut_get_str(v));+ } else if (yyjson_mut_is_real(v)) {+ hg_float(yyjson_mut_get_real(v), out, sz);+ } else if (yyjson_mut_is_int(v)) {+ snprintf(out, sz, "%lld",+ yyjson_mut_is_sint(v) ? (long long)yyjson_mut_get_sint(v)+ : (long long)yyjson_mut_get_uint(v));+ } else if (yyjson_mut_is_bool(v)) {+ snprintf(out, sz, "%s", yyjson_mut_get_bool(v) ? "true" : "false");+ } else {+ return false;+ }+ return true;+}++/* ── Runtime values ───────────────────────────────────────────────── */++typedef enum {+ HV_UNK = 0,+ HV_NIL,+ HV_BOOL,+ HV_INT,+ HV_FLOAT,+ HV_STR,+ HV_JSON,+ HV_MAP,+ HV_LIST+} hv_kind_t;++typedef struct hv hv_t;++typedef struct {+ const char **keys;+ hv_t *vals;+ int n;+ bool strict; /* a struct (.Chart, .Release): a field not held is UNKNOWN */+} hv_map_t;++typedef struct {+ hv_t *items;+ int n;+} hv_list_t;++struct hv {+ hv_kind_t k;+ bool b;+ int64_t i;+ double f;+ const char *s;+ size_t sn;+ yyjson_mut_val *j; /* HV_JSON: an object or array of the values */+ hv_map_t *m;+ hv_list_t *l;+ const char *path; /* the values path it holds; NULL: none */+};++static const hv_t HV_UNKNOWN = {.k = HV_UNK};++static hv_t hv_nil(void) {+ return (hv_t){.k = HV_NIL};+}++static hv_t hv_bool(bool b) {+ return (hv_t){.k = HV_BOOL, .b = b};+}++static hv_t hv_int(int64_t i) {+ return (hv_t){.k = HV_INT, .i = i};+}++static hv_t hv_float(double f) {+ return (hv_t){.k = HV_FLOAT, .f = f};+}++static hv_t hv_str(const char *s, size_t n) {+ return (hv_t){.k = HV_STR, .s = s, .sn = n};+}++static hv_t hv_json(yyjson_mut_val *v, const char *path) {+ hv_t out = {.path = path};+ if (!v || yyjson_mut_is_null(v)) {+ out.k = HV_NIL;+ } else if (yyjson_mut_is_bool(v)) {+ out.k = HV_BOOL;+ out.b = yyjson_mut_get_bool(v);+ } else if (yyjson_mut_is_int(v)) {+ out.k = HV_INT;+ out.i = yyjson_mut_is_sint(v) ? yyjson_mut_get_sint(v) : (int64_t)yyjson_mut_get_uint(v);+ } else if (yyjson_mut_is_real(v)) {+ out.k = HV_FLOAT;+ out.f = yyjson_mut_get_real(v);+ } else if (yyjson_mut_is_str(v)) {+ out.k = HV_STR;+ out.s = yyjson_mut_get_str(v);+ out.sn = yyjson_mut_get_len(v);+ } else if (yyjson_mut_is_obj(v) || yyjson_mut_is_arr(v)) {+ out.k = HV_JSON;+ out.j = v;+ }+ return out;+}++static bool hv_is_map(const hv_t *v) {+ return v->k == HV_MAP || (v->k == HV_JSON && yyjson_mut_is_obj(v->j));+}++static bool hv_is_list(const hv_t *v) {+ return v->k == HV_LIST || (v->k == HV_JSON && yyjson_mut_is_arr(v->j));+}++static int hv_len(const hv_t *v) {+ switch (v->k) {+ case HV_STR:+ return (int)v->sn;+ case HV_MAP:+ return v->m->n;+ case HV_LIST:+ return v->l->n;+ case HV_JSON:+ return (int)(yyjson_mut_is_obj(v->j) ? yyjson_mut_obj_size(v->j)+ : yyjson_mut_arr_size(v->j));+ default:+ return -SKIP_ONE;+ }+}++/* Go template truth (if / with / and / or / not). */+static bool hv_truth(const hv_t *v) {+ switch (v->k) {+ case HV_BOOL:+ return v->b;+ case HV_INT:+ return v->i != 0;+ case HV_FLOAT:+ return v->f != 0;+ case HV_STR:+ case HV_MAP:+ case HV_LIST:+ case HV_JSON:+ return hv_len(v) > 0;+ default:+ return false;+ }+}++/* ── Renderer state ───────────────────────────────────────────────── */++typedef struct {+ const char *name;+ size_t nl;+ hv_t v;+} hvar_t;++typedef struct {+ char *buf;+ size_t n;+ size_t cap;+ bool unk;+} hsink_t;++typedef struct {+ const char *src; /* the text these nodes are of */+ hv_t dot;+ int var_base; /* the template's first variable (`$`) */+ hsink_t *out; /* NULL: the template's own output, which the probes read */+} hframe_t;++typedef struct {+ CBMArena *a;+ yyjson_mut_doc *scratch;+ const cbm_helm_defines_t *defs;+ hvar_t *vars;+ int nvars;+ int vcap;+ int nesting;+ bool brk;+ bool cont;+ /* probes of the top-level template */+ const char *top_src;+ size_t top_len;+ cbm_helm_probe_t *probes;+ int nprobes;+ const uint32_t *lines; /* line start offsets */+ int nlines;+ int capture; /* the probe capturing; -1: none */+ hsink_t cap;+ const char **ckeys;+ int nck;+ int ckcap;+ TSParser *parser;+ TSTree **trees;+ int ntrees;+ int tcap;+} hst_t;++static void hs_append(hst_t *st, hsink_t *s, const char *p, size_t n) {+ if (s->unk || n == 0) {+ return;+ }+ if (s->n + n + SKIP_ONE > s->cap) {+ size_t cap = (s->cap ? s->cap : CBM_SZ_64) * PAIR_LEN;+ while (cap < s->n + n + SKIP_ONE) {+ cap *= PAIR_LEN;+ }+ char *g = cbm_arena_alloc(st->a, cap);+ if (!g) {+ s->unk = true;+ return;+ }+ if (s->n) {+ memcpy(g, s->buf, s->n);+ }+ s->buf = g;+ s->cap = cap;+ }+ memcpy(s->buf + s->n, p, n);+ s->n += n;+ s->buf[s->n] = '\0';+}++static const char *hs_str(hst_t *st, const hsink_t *s) {+ return s->n ? s->buf : cbm_arena_strdup(st->a, "");+}++static void hst_record(hst_t *st, const char *path) {+ if (st->capture < 0 || !path) {+ return;+ }+ for (int i = 0; i < st->nck; i++) {+ if (strcmp(st->ckeys[i], path) == 0) {+ return;+ }+ }+ if (st->nck == st->ckcap) {+ int cap = st->ckcap ? st->ckcap * PAIR_LEN : CBM_SZ_16;+ const char **g = cbm_arena_alloc(st->a, (size_t)cap * sizeof(*g));+ if (!g) {+ return;+ }+ if (st->nck) {+ memcpy(g, st->ckeys, (size_t)st->nck * sizeof(*g));+ }+ st->ckeys = g;+ st->ckcap = cap;+ }+ st->ckeys[st->nck++] = path;+}++/* A values path joined with key `k` (its own `.` escaped). */+static const char *hst_path(hst_t *st, const char *path, const char *k, size_t kl) {+ if (!path) {+ return NULL;+ }+ size_t dots = 0;+ for (size_t i = 0; i < kl; i++) {+ dots += k[i] == '.';+ }+ size_t pl = strlen(path);+ char *out = cbm_arena_alloc(st->a, pl + kl + dots + PAIR_LEN);+ if (!out) {+ return NULL;+ }+ size_t o = 0;+ if (pl) {+ memcpy(out, path, pl);+ o = pl;+ out[o++] = '.';+ }+ for (size_t i = 0; i < kl; i++) {+ if (k[i] == '.') {+ out[o++] = '\\';+ }+ out[o++] = k[i];+ }+ out[o] = '\0';+ return out;+}++static bool hst_var_push(hst_t *st, const char *name, size_t nl, hv_t v) {+ if (st->nvars == st->vcap) {+ int cap = st->vcap ? st->vcap * PAIR_LEN : CBM_SZ_32;+ hvar_t *g = cbm_arena_alloc(st->a, (size_t)cap * sizeof(*g));+ if (!g) {+ return false;+ }+ if (st->nvars) {+ memcpy(g, st->vars, (size_t)st->nvars * sizeof(*g));+ }+ st->vars = g;+ st->vcap = cap;+ }+ st->vars[st->nvars++] = (hvar_t){name, nl, v};+ return true;+}++static hvar_t *hst_var(hst_t *st, const hframe_t *fr, const char *name, size_t nl) {+ for (int i = st->nvars - SKIP_ONE; i >= fr->var_base; i--) {+ if (st->vars[i].nl == nl && memcmp(st->vars[i].name, name, nl) == 0) {+ return &st->vars[i];+ }+ }+ return NULL;+}++static bool hn_is(TSNode n, const char *t) {+ return !ts_node_is_null(n) && strcmp(ts_node_type(n), t) == 0;+}++static const char *hn_text(const hframe_t *fr, TSNode n, size_t *len) {+ uint32_t b = ts_node_start_byte(n);+ *len = ts_node_end_byte(n) - b;+ return fr->src + b;+}++static TSNode hn_field(TSNode n, const char *f) {+ return ts_node_child_by_field_name(n, f, (uint32_t)strlen(f));+}++/* The name of a variable node ("" for `$`). */+static const char *hn_var_name(const hframe_t *fr, TSNode var, size_t *nl) {+ TSNode nm = hn_field(var, "name");+ if (ts_node_is_null(nm)) {+ *nl = 0;+ return "";+ }+ return hn_text(fr, nm, nl);+}++/* ── Printing ─────────────────────────────────────────────────────── */++/* Go's %v of a basic value into the arena; NULL for one not modelled. */+static const char *hv_fmt(hst_t *st, const hv_t *v, size_t *len) {+ char buf[CBM_SZ_64];+ switch (v->k) {+ case HV_STR:+ *len = v->sn;+ return v->s;+ case HV_BOOL:+ *len = v->b ? 4 : 5;+ return v->b ? "true" : "false";+ case HV_INT:+ snprintf(buf, sizeof(buf), "%lld", (long long)v->i);+ break;+ case HV_FLOAT:+ hg_float(v->f, buf, sizeof(buf));+ break;+ case HV_NIL:+ *len = 5;+ return "<nil>";+ default:+ return NULL;+ }+ char *out = cbm_arena_strdup(st->a, buf);+ *len = out ? strlen(out) : 0;+ return out;+}++/* Sprig's strval. */+static bool hv_strval(hst_t *st, const hv_t *v, hv_t *out) {+ size_t n = 0;+ const char *s = hv_fmt(st, v, &n);+ if (!s) {+ return false;+ }+ *out = hv_str(s, n);+ return true;+}++/* ── Output and probes ────────────────────────────────────────────── */++/* A capture's scalar with its YAML quoting removed; NULL: none / invalid. */+static const char *hst_scalar(hst_t *st, const char *s, size_t n) {+ while (n && (*s == ' ' || *s == '\t')) {+ s++;+ n--;+ }+ while (n && (s[n - SKIP_ONE] == ' ' || s[n - SKIP_ONE] == '\t' || s[n - SKIP_ONE] == '\r')) {+ n--;+ }+ if (n == 0) {+ return NULL;+ }+ if (s[0] == '"' || s[0] == '\'') {+ /* the closing quote: \" escapes one in "..", '' one in '..' */+ size_t e = SKIP_ONE;+ for (; e < n; e++) {+ if (s[0] == '"' && s[e] == '\\') {+ e++;+ } else if (s[0] == '\'' && s[e] == '\'' && e + SKIP_ONE < n &&+ s[e + SKIP_ONE] == '\'') {+ e++;+ } else if (s[e] == s[0]) {+ break;+ }+ }+ if (e >= n) {+ return NULL;+ }+ for (size_t r = e + SKIP_ONE; r < n; r++) {+ if (s[r] == '#') {+ break;+ }+ if (s[r] != ' ' && s[r] != '\t') {+ return NULL;+ }+ }+ yyjson_mut_val *v = cbm_helm_values_parse(st->scratch, s, e + SKIP_ONE);+ return v && yyjson_mut_is_str(v) ? cbm_arena_strdup(st->a, yyjson_mut_get_str(v)) : NULL;+ }+ for (size_t i = 0; i < n; i++) {+ if (s[i] == '#' && i > 0 && (s[i - SKIP_ONE] == ' ' || s[i - SKIP_ONE] == '\t')) {+ n = i;+ break;+ }+ if (s[i] == ':' && (i + SKIP_ONE == n || s[i + SKIP_ONE] == ' ')) {+ return NULL; /* a mapping, no scalar */+ }+ }+ while (n && (s[n - SKIP_ONE] == ' ' || s[n - SKIP_ONE] == '\t')) {+ n--;+ }+ return n ? cbm_arena_strndup(st->a, s, n) : NULL;+}++static void hst_capture_end(hst_t *st) {+ if (st->capture < 0) {+ return;+ }+ cbm_helm_probe_t *p = &st->probes[st->capture];+ const char **img = cbm_arena_alloc(st->a, (size_t)(p->n + SKIP_ONE) * sizeof(*img));+ const char **keys = cbm_arena_alloc(st->a, (size_t)(p->n + SKIP_ONE) * sizeof(*keys));+ if (img && keys) {+ if (p->n) {+ memcpy(img, p->image, (size_t)p->n * sizeof(*img));+ memcpy(keys, p->keys, (size_t)p->n * sizeof(*keys));+ }+ img[p->n] = st->cap.unk ? NULL : hst_scalar(st, st->cap.buf ? st->cap.buf : "", st->cap.n);+ /* the leaves read: a path that is the prefix of another is dropped */+ const char *json = NULL;+ for (int i = 0; i < st->nck; i++) {+ size_t li = strlen(st->ckeys[i]);+ bool prefix = false;+ for (int j = 0; j < st->nck && !prefix; j++) {+ prefix = j != i && strncmp(st->ckeys[j], st->ckeys[i], li) == 0 &&+ st->ckeys[j][li] == '.';+ }+ if (prefix || !st->ckeys[i][0]) {+ continue;+ }+ char esc[CBM_SZ_1K];+ size_t o = 0;+ for (const char *c = st->ckeys[i]; *c && o + 3 < sizeof(esc); c++) {+ if (*c == '"' || *c == '\\') {+ esc[o++] = '\\';+ }+ esc[o++] = *c;+ }+ esc[o] = '\0';+ json = cbm_arena_sprintf(st->a, "%s%s\"%s\"", json ? json : "[", json ? "," : "", esc);+ }+ keys[p->n] = json ? cbm_arena_sprintf(st->a, "%s]", json) : NULL;+ p->image = img;+ p->keys = keys;+ p->n++;+ }+ st->capture = -SKIP_ONE;+ st->cap = (hsink_t){0};+ st->nck = 0;+}++/* Output of the top-level template: into the capture until its newline. */+static void hst_out(hst_t *st, hframe_t *fr, const char *p, size_t n) {+ if (fr->out) {+ hs_append(st, fr->out, p, n);+ return;+ }+ if (st->capture < 0) {+ return;+ }+ const char *nl = memchr(p, '\n', n);+ hs_append(st, &st->cap, p, nl ? (size_t)(nl - p) : n);+ if (nl) {+ hst_capture_end(st);+ }+}++static void hst_out_unknown(hst_t *st, hframe_t *fr) {+ if (fr->out) {+ fr->out->unk = true;+ } else if (st->capture >= 0) {+ st->cap.unk = true;+ }+}++/* Output of a value as text/template prints it (nil: "", as Helm). */+static void hst_out_value(hst_t *st, hframe_t *fr, const hv_t *v) {+ if (v->k == HV_NIL) {+ return;+ }+ size_t n = 0;+ const char *s = hv_fmt(st, v, &n);+ if (!s) {+ hst_out_unknown(st, fr);+ return;+ }+ hst_out(st, fr, s, n);+}++static bool hn_ws(char c) {+ return c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == '\v' || c == '\f';+}++/* A text node, trimmed by an adjacent `-}}` / `{{-`; at the top level each+ * probe whose `image:` key it holds starts its capture after the key. */+static void hst_text(hst_t *st, hframe_t *fr, TSNode n) {+ uint32_t b = ts_node_start_byte(n);+ uint32_t e = ts_node_end_byte(n);+ /* the markers are lexical -- `{{- ` / ` -}}` beside the text, whichever+ * action (of whatever nesting) they open or close */+ if (b >= 4 && strncmp(fr->src + b - 3, "-}}", 3) == 0 && hn_ws(fr->src[b - 4])) {+ while (b < e && hn_ws(fr->src[b])) {+ b++;+ }+ }+ if (strncmp(fr->src + e, "{{-", 3) == 0 && hn_ws(fr->src[e + 3])) {+ while (e > b && hn_ws(fr->src[e - SKIP_ONE])) {+ e--;+ }+ }+ if (fr->out || fr->src != st->top_src) {+ hst_out(st, fr, fr->src + b, e - b);+ return;+ }+ uint32_t at = b;+ for (;;) {+ /* the next probe key in [at, e) */+ uint32_t key = e;+ int which = -SKIP_ONE;+ for (int i = 0; i < st->nprobes; i++) {+ int line = st->probes[i].line;+ if (line < SKIP_ONE || line > st->nlines) {+ continue;+ }+ uint32_t k = st->lines[line - SKIP_ONE];+ while (k < st->top_len && (st->top_src[k] == ' ' || st->top_src[k] == '\t')) {+ k++;+ }+ if (k < st->top_len && st->top_src[k] == '-' && k + SKIP_ONE < st->top_len &&+ st->top_src[k + SKIP_ONE] == ' ') {+ k++;+ while (k < st->top_len && st->top_src[k] == ' ') {+ k++;+ }+ }+ if (k >= at && k < key && k + strlen("image:") <= e &&+ memcmp(st->top_src + k, "image:", strlen("image:")) == 0) {+ key = k;+ which = i;+ }+ }+ if (which < 0) {+ hst_out(st, fr, fr->src + at, e - at);+ return;+ }+ uint32_t after = key + (uint32_t)strlen("image:");+ hst_out(st, fr, fr->src + at, after - at);+ hst_capture_end(st);+ st->capture = which;+ st->cap = (hsink_t){0};+ st->nck = 0;+ at = after;+ }+}++/* ── Evaluation ───────────────────────────────────────────────────── */++static hv_t he_eval(hst_t *st, hframe_t *fr, TSNode n);+static void he_items(hst_t *st, hframe_t *fr, TSNode parent, const char *field);+static hv_t he_render_define(hst_t *st, const char *name, hv_t arg, hsink_t *into);++/* Field `name` of value v. */+static hv_t he_field(hst_t *st, const hv_t *v, const char *name, size_t nl) {+ if (v->k == HV_MAP) {+ for (int i = 0; i < v->m->n; i++) {+ if (strlen(v->m->keys[i]) == nl && memcmp(v->m->keys[i], name, nl) == 0) {+ hst_record(st, v->m->vals[i].path);+ return v->m->vals[i];+ }+ }+ return v->m->strict ? HV_UNKNOWN : hv_nil();+ }+ if (v->k == HV_JSON && yyjson_mut_is_obj(v->j)) {+ const char *path = hst_path(st, v->path, name, nl);+ yyjson_mut_val *c = yyjson_mut_obj_getn(v->j, name, nl);+ hst_record(st, path);+ return hv_json(c, path);+ }+ return HV_UNKNOWN; /* a field of nil, of a scalar, of a list: an error */+}++static hv_t he_index1(hst_t *st, const hv_t *v, const hv_t *k) {+ if (hv_is_map(v)) {+ if (k->k != HV_STR) {+ return HV_UNKNOWN;+ }+ return he_field(st, v, k->s, k->sn);+ }+ if (hv_is_list(v)) {+ if (k->k != HV_INT) {+ return HV_UNKNOWN;+ }+ if (v->k == HV_LIST) {+ return k->i >= 0 && k->i < v->l->n ? v->l->items[k->i] : HV_UNKNOWN;+ }+ yyjson_mut_val *c = k->i >= 0 ? yyjson_mut_arr_get(v->j, (size_t)k->i) : NULL;+ if (!c) {+ return HV_UNKNOWN;+ }+ const char *path =+ v->path ? cbm_arena_sprintf(st->a, "%s[%lld]", v->path, (long long)k->i) : NULL;+ hst_record(st, path);+ return hv_json(c, path);+ }+ return v->k == HV_NIL ? hv_nil() : HV_UNKNOWN;+}++/* Sprig empty. */+static bool hv_empty(const hv_t *v) {+ return !hv_truth(v);+}++static bool hv_eq(const hv_t *a, const hv_t *b, bool *ok) {+ *ok = true;+ if (a->k == HV_STR && b->k == HV_STR) {+ return a->sn == b->sn && memcmp(a->s, b->s, a->sn) == 0;+ }+ if (a->k == HV_BOOL && b->k == HV_BOOL) {+ return a->b == b->b;+ }+ if (a->k == HV_INT && b->k == HV_INT) {+ return a->i == b->i;+ }+ if (a->k == HV_FLOAT && b->k == HV_FLOAT) {+ return a->f == b->f;+ }+ *ok = false; /* incompatible kinds: an error in Go */+ return false;+}++static hv_t hv_mklist(hst_t *st, const hv_t *items, int n) {+ hv_list_t *l = cbm_arena_alloc(st->a, sizeof(*l));+ hv_t *v = n ? cbm_arena_alloc(st->a, (size_t)n * sizeof(*v)) : NULL;+ if (!l || (n && !v)) {+ return HV_UNKNOWN;+ }+ if (n) {+ memcpy(v, items, (size_t)n * sizeof(*v));+ }+ *l = (hv_list_t){v, n};+ return (hv_t){.k = HV_LIST, .l = l};+}++/* The items of a list value into an arena array; -1 when it is none. */+static int hv_items(hst_t *st, const hv_t *v, hv_t **out) {+ if (v->k == HV_LIST) {+ *out = v->l->items;+ return v->l->n;+ }+ if (v->k == HV_JSON && yyjson_mut_is_arr(v->j)) {+ int n = (int)yyjson_mut_arr_size(v->j);+ hv_t *items = n ? cbm_arena_alloc(st->a, (size_t)n * sizeof(*items)) : NULL;+ if (n && !items) {+ return -SKIP_ONE;+ }+ size_t idx, max;+ yyjson_mut_val *it;+ yyjson_mut_arr_foreach(v->j, idx, max, it) {+ const char *path = v->path ? cbm_arena_sprintf(st->a, "%s[%zu]", v->path, idx) : NULL;+ items[idx] = hv_json(it, path);+ }+ *out = items;+ return n;+ }+ if (v->k == HV_NIL) {+ *out = NULL;+ return 0;+ }+ return -SKIP_ONE;+}++static int he_key_cmp(const void *x, const void *y) {+ return strcmp(*(const char *const *)x, *(const char *const *)y);+}++/* A map's keys, sorted (Go's order for range), into an arena array. */+static int hv_keys(hst_t *st, const hv_t *v, const char ***out) {+ int n = hv_len(v);+ const char **keys = n > 0 ? cbm_arena_alloc(st->a, (size_t)n * sizeof(*keys)) : NULL;+ if (n > 0 && !keys) {+ return -SKIP_ONE;+ }+ if (v->k == HV_MAP) {+ for (int i = 0; i < n; i++) {+ keys[i] = v->m->keys[i];+ }+ } else {+ size_t idx, max;+ yyjson_mut_val *k, *val;+ yyjson_mut_obj_foreach(v->j, idx, max, k, val) {+ (void)val;+ keys[idx] = yyjson_mut_get_str(k);+ }+ }+ if (n > SKIP_ONE) {+ qsort(keys, (size_t)n, sizeof(*keys), he_key_cmp);+ }+ *out = keys;+ return n;+}++static bool hv_to_int(const hv_t *v, int64_t *out) {+ switch (v->k) {+ case HV_INT:+ *out = v->i;+ return true;+ case HV_FLOAT:+ *out = (int64_t)v->f;+ return true;+ case HV_BOOL:+ *out = v->b ? SKIP_ONE : 0;+ return true;+ case HV_NIL:+ *out = 0;+ return true;+ case HV_STR: {+ char buf[CBM_SZ_64];+ if (v->sn == 0 || v->sn >= sizeof(buf)) {+ *out = 0;+ return v->sn == 0;+ }+ memcpy(buf, v->s, v->sn);+ buf[v->sn] = '\0';+ char *end = NULL;+ long long i = strtoll(buf, &end, 0);+ if (end && !*end) {+ *out = i;+ return true;+ }+ double d = strtod(buf, &end);+ *out = end && !*end ? (int64_t)d : 0;+ return true;+ }+ default:+ return false;+ }+}++/* Go's %q of s. */+static const char *hg_quote(hst_t *st, const char *s, size_t n, char q) {+ char *out = cbm_arena_alloc(st->a, n * 4 + 3);+ if (!out) {+ return NULL;+ }+ size_t k = 0;+ out[k++] = q;+ for (size_t i = 0; i < n; i++) {+ unsigned char c = (unsigned char)s[i];+ if (q == '"' && (c == '"' || c == '\\')) {+ out[k++] = '\\';+ out[k++] = (char)c;+ } else if (q == '"' && c < 0x20) {+ static const char HEX[] = "0123456789abcdef";+ const char *named = c == '\n' ? "\\n" : c == '\t' ? "\\t" : c == '\r' ? "\\r" : NULL;+ if (named) {+ out[k++] = named[0];+ out[k++] = named[1];+ } else {+ out[k++] = '\\';+ out[k++] = 'x';+ out[k++] = HEX[c >> 4];+ out[k++] = HEX[c & 0xF];+ }+ } else {+ out[k++] = (char)c;+ }+ }+ out[k++] = q;+ out[k] = '\0';+ return out;+}++/* fmt.Sprintf for the verbs %s %v %d %q %% without flags; NULL otherwise. */+static const char *he_printf(hst_t *st, const hv_t *args, int n) {+ if (n < SKIP_ONE || args[0].k != HV_STR) {+ return NULL;+ }+ hsink_t out = {0};+ int ai = SKIP_ONE;+ const char *f = args[0].s;+ size_t fl = args[0].sn;+ for (size_t i = 0; i < fl; i++) {+ if (f[i] != '%') {+ hs_append(st, &out, f + i, SKIP_ONE);+ continue;+ }+ if (++i >= fl) {+ return NULL;+ }+ char verb = f[i];+ if (verb == '%') {+ hs_append(st, &out, "%", SKIP_ONE);+ continue;+ }+ if (ai >= n) {+ return NULL;+ }+ const hv_t *a = &args[ai++];+ size_t sl = 0;+ const char *s = NULL;+ if (verb == 's' && a->k == HV_STR) {+ s = a->s;+ sl = a->sn;+ } else if (verb == 'v') {+ s = hv_fmt(st, a, &sl);+ } else if (verb == 'd' && a->k == HV_INT) {+ s = hv_fmt(st, a, &sl);+ } else if (verb == 'q' && a->k == HV_STR) {+ s = hg_quote(st, a->s, a->sn, '"');+ sl = s ? strlen(s) : 0;+ }+ if (!s) {+ return NULL; /* %!s(float64=...) and the like: no image */+ }+ hs_append(st, &out, s, sl);+ }+ if (ai != n || out.unk) {+ return NULL;+ }+ return hs_str(st, &out);+}++static hv_t he_strfn(hst_t *st, const char *fn, const hv_t *a, int n) {+ /* Sprig string functions take the subject last. */+ hv_t s;+ if (n < SKIP_ONE || !hv_strval(st, &a[n - SKIP_ONE], &s)) {+ return HV_UNKNOWN;+ }+ if (strcmp(fn, "trim") == 0 && n == SKIP_ONE) {+ size_t b = 0;+ size_t e = s.sn;+ while (b < e && hn_ws(s.s[b])) {+ b++;+ }+ while (e > b && hn_ws(s.s[e - SKIP_ONE])) {+ e--;+ }+ return hv_str(s.s + b, e - b);+ }+ if ((strcmp(fn, "lower") == 0 || strcmp(fn, "upper") == 0) && n == SKIP_ONE) {+ char *o = cbm_arena_strndup(st->a, s.s, s.sn);+ for (size_t i = 0; o && i < s.sn; i++) {+ o[i] =+ (char)(fn[0] == 'l' ? tolower((unsigned char)o[i]) : toupper((unsigned char)o[i]));+ }+ return o ? hv_str(o, s.sn) : HV_UNKNOWN;+ }+ if (n != PAIR_LEN && strcmp(fn, "replace") != 0) {+ return HV_UNKNOWN;+ }+ hv_t p;+ if (!hv_strval(st, &a[0], &p)) {+ return HV_UNKNOWN;+ }+ if (strcmp(fn, "trimPrefix") == 0) {+ bool has = p.sn <= s.sn && memcmp(s.s, p.s, p.sn) == 0;+ return has ? hv_str(s.s + p.sn, s.sn - p.sn) : s;+ }+ if (strcmp(fn, "trimSuffix") == 0) {+ bool has = p.sn <= s.sn && memcmp(s.s + s.sn - p.sn, p.s, p.sn) == 0;+ return has ? hv_str(s.s, s.sn - p.sn) : s;+ }+ if (strcmp(fn, "trimAll") == 0) {+ size_t b = 0;+ size_t e = s.sn;+ while (b < e && memchr(p.s, s.s[b], p.sn)) {+ b++;+ }+ while (e > b && memchr(p.s, s.s[e - SKIP_ONE], p.sn)) {+ e--;+ }+ return hv_str(s.s + b, e - b);+ }+ if (strcmp(fn, "contains") == 0 || strcmp(fn, "hasPrefix") == 0 ||+ strcmp(fn, "hasSuffix") == 0) {+ if (p.sn > s.sn) {+ return hv_bool(false);+ }+ if (fn[0] == 'c') {+ char *hs = cbm_arena_strndup(st->a, s.s, s.sn);+ char *ns = cbm_arena_strndup(st->a, p.s, p.sn);+ return hs && ns ? hv_bool(strstr(hs, ns) != NULL) : HV_UNKNOWN;+ }+ const char *at = fn[3] == 'P' ? s.s : s.s + s.sn - p.sn;+ return hv_bool(memcmp(at, p.s, p.sn) == 0);+ }+ if (strcmp(fn, "trunc") == 0) {+ int64_t c = 0;+ if (!hv_to_int(&a[0], &c)) {+ return HV_UNKNOWN;+ }+ if (c >= 0) {+ return hv_str(s.s, (size_t)c < s.sn ? (size_t)c : s.sn);+ }+ size_t keep = (size_t)(-c) < s.sn ? (size_t)(-c) : s.sn;+ return hv_str(s.s + s.sn - keep, keep);+ }+ if (strcmp(fn, "replace") == 0 && n == 3) {+ hv_t to;+ if (!hv_strval(st, &a[SKIP_ONE], &to) || p.sn == 0) {+ return HV_UNKNOWN;+ }+ hsink_t out = {0};+ for (size_t i = 0; i < s.sn;) {+ if (i + p.sn <= s.sn && memcmp(s.s + i, p.s, p.sn) == 0) {+ hs_append(st, &out, to.s, to.sn);+ i += p.sn;+ } else {+ hs_append(st, &out, s.s + i, SKIP_ONE);+ i++;+ }+ }+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ return HV_UNKNOWN;+}++/* A function call `fn` with its evaluated arguments (the piped value last). */+static hv_t he_apply(hst_t *st, hframe_t *fr, const char *fn, hv_t *a, int n) {+ for (int i = 0; i < n; i++) {+ if (a[i].k == HV_UNK) {+ return HV_UNKNOWN;+ }+ }+ if (strcmp(fn, "include") == 0 && n == PAIR_LEN && a[0].k == HV_STR) {+ hsink_t out = {0};+ char *name = cbm_arena_strndup(st->a, a[0].s, a[0].sn);+ hv_t r = name ? he_render_define(st, name, a[1], &out) : HV_UNKNOWN;+ return r.k == HV_UNK || out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if (strcmp(fn, "tpl") == 0 && n == PAIR_LEN && a[0].k == HV_STR) {+ if (!st->parser) {+ return HV_UNKNOWN;+ }+ char *src = cbm_arena_strndup(st->a, a[0].s, a[0].sn);+ TSTree *t = src ? ts_parser_parse_string(st->parser, NULL, src, (uint32_t)a[0].sn) : NULL;+ if (!t) {+ return HV_UNKNOWN;+ }+ if (st->ntrees == st->tcap) {+ int cap = st->tcap ? st->tcap * PAIR_LEN : CBM_SZ_16;+ TSTree **g = cbm_arena_alloc(st->a, (size_t)cap * sizeof(*g));+ if (!g) {+ ts_tree_delete(t);+ return HV_UNKNOWN;+ }+ if (st->ntrees) {+ memcpy(g, st->trees, (size_t)st->ntrees * sizeof(*g));+ }+ st->trees = g;+ st->tcap = cap;+ }+ st->trees[st->ntrees++] = t;+ TSNode root = ts_tree_root_node(t);+ if (ts_node_has_error(root) || ++st->nesting > HELM_MAX_NESTING) {+ st->nesting -= ts_node_has_error(root) ? 0 : SKIP_ONE;+ return HV_UNKNOWN;+ }+ hsink_t out = {0};+ int mark = st->nvars;+ hframe_t sub = {.src = src, .dot = a[1], .var_base = st->nvars, .out = &out};+ hst_var_push(st, "", 0, a[1]);+ he_items(st, &sub, root, NULL);+ st->nvars = mark;+ st->nesting--;+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if (strcmp(fn, "default") == 0 && n >= SKIP_ONE) {+ return n == SKIP_ONE || hv_empty(&a[SKIP_ONE]) ? a[0] : a[SKIP_ONE];+ }+ if (strcmp(fn, "coalesce") == 0) {+ for (int i = 0; i < n; i++) {+ if (!hv_empty(&a[i])) {+ return a[i];+ }+ }+ return hv_nil();+ }+ if (strcmp(fn, "ternary") == 0 && n == 3) {+ return a[2].k == HV_BOOL ? (a[2].b ? a[0] : a[SKIP_ONE]) : HV_UNKNOWN;+ }+ if (strcmp(fn, "empty") == 0 && n == SKIP_ONE) {+ return hv_bool(hv_empty(&a[0]));+ }+ if (strcmp(fn, "not") == 0 && n == SKIP_ONE) {+ return hv_bool(!hv_truth(&a[0]));+ }+ if ((strcmp(fn, "eq") == 0 && n >= PAIR_LEN) || (strcmp(fn, "ne") == 0 && n == PAIR_LEN)) {+ bool any = false;+ for (int i = SKIP_ONE; i < n; i++) {+ bool ok = false;+ any = any || hv_eq(&a[0], &a[i], &ok);+ if (!ok) {+ return HV_UNKNOWN;+ }+ }+ return hv_bool(fn[0] == 'e' ? any : !any);+ }+ if (strcmp(fn, "required") == 0 && n == PAIR_LEN) {+ bool missing = a[1].k == HV_NIL || (a[1].k == HV_STR && a[1].sn == 0);+ return missing ? HV_UNKNOWN : a[1];+ }+ if (strcmp(fn, "printf") == 0) {+ const char *s = he_printf(st, a, n);+ return s ? hv_str(s, strlen(s)) : HV_UNKNOWN;+ }+ if (strcmp(fn, "print") == 0 || strcmp(fn, "cat") == 0) {+ hsink_t out = {0};+ bool prev_str = true;+ int written = 0;+ for (int i = 0; i < n; i++) {+ if (fn[0] == 'c' && a[i].k == HV_NIL) {+ continue;+ }+ size_t sl = 0;+ const char *s = hv_fmt(st, &a[i], &sl);+ if (!s) {+ return HV_UNKNOWN;+ }+ bool is_str = a[i].k == HV_STR;+ /* fmt.Sprint spaces two operands neither of which is a string; cat always */+ if (written && (fn[0] == 'c' || (!is_str && !prev_str))) {+ hs_append(st, &out, " ", SKIP_ONE);+ }+ hs_append(st, &out, s, sl);+ prev_str = is_str;+ written++;+ }+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if (strcmp(fn, "quote") == 0 || strcmp(fn, "squote") == 0) {+ hsink_t out = {0};+ int written = 0;+ for (int i = 0; i < n; i++) {+ hv_t s;+ if (a[i].k == HV_NIL) {+ continue;+ }+ if (!hv_strval(st, &a[i], &s)) {+ return HV_UNKNOWN;+ }+ const char *q = fn[0] == 'q' ? hg_quote(st, s.s, s.sn, '"')+ : cbm_arena_sprintf(st->a, "'%.*s'", (int)s.sn, s.s);+ if (!q) {+ return HV_UNKNOWN;+ }+ if (written++) {+ hs_append(st, &out, " ", SKIP_ONE);+ }+ hs_append(st, &out, q, strlen(q));+ }+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if (strcmp(fn, "toString") == 0 && n == SKIP_ONE) {+ hv_t s;+ return hv_strval(st, &a[0], &s) ? s : HV_UNKNOWN;+ }+ if ((strcmp(fn, "int") == 0 || strcmp(fn, "int64") == 0 || strcmp(fn, "toInt") == 0) &&+ n == SKIP_ONE) {+ int64_t i = 0;+ return hv_to_int(&a[0], &i) ? hv_int(i) : HV_UNKNOWN;+ }+ if (strcmp(fn, "float64") == 0 && n == SKIP_ONE) {+ int64_t i = 0;+ return a[0].k == HV_FLOAT ? a[0] : hv_to_int(&a[0], &i) ? hv_float((double)i) : HV_UNKNOWN;+ }+ if (strcmp(fn, "len") == 0 && n == SKIP_ONE) {+ int l = hv_len(&a[0]);+ return l >= 0 ? hv_int(l) : HV_UNKNOWN;+ }+ if (strcmp(fn, "dict") == 0) {+ hv_map_t *m = cbm_arena_calloc(st->a, sizeof(*m));+ int pairs = (n + SKIP_ONE) / PAIR_LEN;+ if (!m) {+ return HV_UNKNOWN;+ }+ m->keys = pairs ? cbm_arena_alloc(st->a, (size_t)pairs * sizeof(*m->keys)) : NULL;+ m->vals = pairs ? cbm_arena_alloc(st->a, (size_t)pairs * sizeof(*m->vals)) : NULL;+ if (pairs && (!m->keys || !m->vals)) {+ return HV_UNKNOWN;+ }+ for (int i = 0; i + SKIP_ONE <= n; i += PAIR_LEN) {+ hv_t k;+ if (!hv_strval(st, &a[i], &k)) {+ return HV_UNKNOWN;+ }+ const char *key = cbm_arena_strndup(st->a, k.s, k.sn);+ hv_t val = i + SKIP_ONE < n ? a[i + SKIP_ONE] : hv_str("", 0);+ int at = m->n;+ for (int j = 0; j < m->n; j++) {+ if (strcmp(m->keys[j], key) == 0) {+ at = j;+ }+ }+ m->keys[at] = key;+ m->vals[at] = val;+ m->n += at == m->n;+ }+ return (hv_t){.k = HV_MAP, .m = m};+ }+ if (strcmp(fn, "list") == 0) {+ return hv_mklist(st, a, n);+ }+ if (strcmp(fn, "get") == 0 && n == PAIR_LEN) {+ if (!hv_is_map(&a[0]) || a[1].k != HV_STR) {+ return HV_UNKNOWN;+ }+ hv_t v = he_field(st, &a[0], a[1].s, a[1].sn);+ return v.k == HV_NIL ? hv_str("", 0) : v;+ }+ if (strcmp(fn, "hasKey") == 0 && n == PAIR_LEN) {+ if (!hv_is_map(&a[0]) || a[1].k != HV_STR) {+ return HV_UNKNOWN;+ }+ if (a[0].k == HV_MAP) {+ for (int i = 0; i < a[0].m->n; i++) {+ if (strlen(a[0].m->keys[i]) == a[1].sn &&+ memcmp(a[0].m->keys[i], a[1].s, a[1].sn) == 0) {+ return hv_bool(true);+ }+ }+ return hv_bool(false);+ }+ hst_record(st, hst_path(st, a[0].path, a[1].s, a[1].sn));+ return hv_bool(yyjson_mut_obj_getn(a[0].j, a[1].s, a[1].sn) != NULL);+ }+ if (strcmp(fn, "index") == 0 && n >= SKIP_ONE) {+ hv_t v = a[0];+ for (int i = SKIP_ONE; i < n && v.k != HV_UNK; i++) {+ v = he_index1(st, &v, &a[i]);+ }+ return v;+ }+ if ((strcmp(fn, "first") == 0 || strcmp(fn, "last") == 0) && n == SKIP_ONE) {+ hv_t *items = NULL;+ int c = hv_items(st, &a[0], &items);+ if (c < 0) {+ return HV_UNKNOWN;+ }+ return c == 0 ? hv_nil() : items[fn[0] == 'f' ? 0 : c - SKIP_ONE];+ }+ if (strcmp(fn, "join") == 0 && n == PAIR_LEN) {+ hv_t *items = NULL;+ int c = hv_items(st, &a[1], &items);+ hv_t sep;+ if (c < 0 || !hv_strval(st, &a[0], &sep)) {+ return HV_UNKNOWN;+ }+ hsink_t out = {0};+ for (int i = 0; i < c; i++) {+ hv_t s;+ if (!hv_strval(st, &items[i], &s)) {+ return HV_UNKNOWN;+ }+ if (i) {+ hs_append(st, &out, sep.s, sep.sn);+ }+ hs_append(st, &out, s.s, s.sn);+ }+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if (strcmp(fn, "splitList") == 0 && n == PAIR_LEN && a[0].k == HV_STR && a[1].k == HV_STR &&+ a[0].sn > 0) {+ int cap = SKIP_ONE;+ for (size_t i = 0; i + a[0].sn <= a[1].sn; i++) {+ cap += memcmp(a[1].s + i, a[0].s, a[0].sn) == 0;+ }+ hv_t *items = cbm_arena_alloc(st->a, (size_t)cap * sizeof(*items));+ if (!items) {+ return HV_UNKNOWN;+ }+ int c = 0;+ size_t from = 0;+ for (size_t i = 0; i + a[0].sn <= a[1].sn;) {+ if (memcmp(a[1].s + i, a[0].s, a[0].sn) == 0) {+ items[c++] = hv_str(a[1].s + from, i - from);+ i += a[0].sn;+ from = i;+ } else {+ i++;+ }+ }+ items[c++] = hv_str(a[1].s + from, a[1].sn - from);+ return hv_mklist(st, items, c);+ }+ if ((strcmp(fn, "nindent") == 0 || strcmp(fn, "indent") == 0) && n == PAIR_LEN) {+ int64_t w = 0;+ hv_t s;+ if (!hv_to_int(&a[0], &w) || w < 0 || !hv_strval(st, &a[1], &s)) {+ return HV_UNKNOWN;+ }+ hsink_t out = {0};+ if (fn[0] == 'n') {+ hs_append(st, &out, "\n", SKIP_ONE);+ }+ for (int64_t i = 0; i < w; i++) {+ hs_append(st, &out, " ", SKIP_ONE);+ }+ for (size_t i = 0; i < s.sn; i++) {+ hs_append(st, &out, s.s + i, SKIP_ONE);+ for (int64_t k = 0; s.s[i] == '\n' && k < w; k++) {+ hs_append(st, &out, " ", SKIP_ONE);+ }+ }+ return out.unk ? HV_UNKNOWN : hv_str(hs_str(st, &out), out.n);+ }+ if ((strcmp(fn, "kindIs") == 0 && n == PAIR_LEN) || (strcmp(fn, "kindOf") == 0 && n == 1)) {+ const hv_t *v = &a[n - SKIP_ONE];+ const char *kind = v->k == HV_NIL ? "invalid"+ : v->k == HV_BOOL ? "bool"+ : v->k == HV_INT ? (v->path ? "int64" : "int")+ : v->k == HV_FLOAT ? "float64"+ : v->k == HV_STR ? "string"+ : hv_is_map(v) ? "map"+ : hv_is_list(v) ? "slice"+ : NULL;+ if (!kind) {+ return HV_UNKNOWN;+ }+ if (fn[4] == 'O') {+ return hv_str(kind, strlen(kind));+ }+ return a[0].k == HV_STR+ ? hv_bool(strlen(kind) == a[0].sn && memcmp(kind, a[0].s, a[0].sn) == 0)+ : HV_UNKNOWN;+ }+ if (strcmp(fn, "dig") == 0 && n >= 3) {+ hv_t v = a[n - SKIP_ONE];+ for (int i = 0; i < n - PAIR_LEN; i++) {+ if (!hv_is_map(&v) || a[i].k != HV_STR) {+ return HV_UNKNOWN;+ }+ v = he_field(st, &v, a[i].s, a[i].sn);+ if (v.k == HV_NIL) {+ return a[n - PAIR_LEN];+ }+ }+ return v;+ }+ if (strcmp(fn, "trim") == 0 || strcmp(fn, "trimPrefix") == 0 || strcmp(fn, "trimSuffix") == 0 ||+ strcmp(fn, "trimAll") == 0 || strcmp(fn, "lower") == 0 || strcmp(fn, "upper") == 0 ||+ strcmp(fn, "replace") == 0 || strcmp(fn, "trunc") == 0 || strcmp(fn, "contains") == 0 ||+ strcmp(fn, "hasPrefix") == 0 || strcmp(fn, "hasSuffix") == 0) {+ return he_strfn(st, fn, a, n);+ }+ (void)fr;+ return HV_UNKNOWN; /* not modelled (toYaml, lookup, regex, semver, merge, ...) */+}++/* A function call node -- `fn args...` or a bare `fn` -- with `piped` (may+ * be NULL) as its last argument. and / or evaluate lazily. */+static hv_t he_call(hst_t *st, hframe_t *fr, TSNode call, const hv_t *piped) {+ TSNode fnode = hn_is(call, "identifier") ? call : hn_field(call, "function");+ if (ts_node_is_null(fnode)) {+ return HV_UNKNOWN;+ }+ size_t fl = 0;+ const char *ft = hn_text(fr, fnode, &fl);+ char fn[CBM_SZ_64];+ if (fl >= sizeof(fn)) {+ return HV_UNKNOWN;+ }+ memcpy(fn, ft, fl);+ fn[fl] = '\0';+ TSNode args = hn_is(call, "identifier") ? (TSNode){0} : hn_field(call, "arguments");+ uint32_t na = ts_node_is_null(args) ? 0 : ts_node_named_child_count(args);+ bool lazy = strcmp(fn, "and") == 0 || strcmp(fn, "or") == 0;+ if (lazy) {+ hv_t v = HV_UNKNOWN;+ uint32_t total = na + (piped ? SKIP_ONE : 0);+ for (uint32_t i = 0; i < total; i++) {+ v = i < na ? he_eval(st, fr, ts_node_named_child(args, i)) : *piped;+ if (v.k == HV_UNK) {+ return HV_UNKNOWN;+ }+ bool t = hv_truth(&v);+ if ((fn[0] == 'a' && !t) || (fn[0] == 'o' && t)) {+ return v;+ }+ }+ return total ? v : HV_UNKNOWN;+ }+ int n = (int)na + (piped ? SKIP_ONE : 0);+ hv_t *a = n ? cbm_arena_alloc(st->a, (size_t)n * sizeof(*a)) : NULL;+ if (n && !a) {+ return HV_UNKNOWN;+ }+ for (uint32_t i = 0; i < na; i++) {+ a[i] = he_eval(st, fr, ts_node_named_child(args, i));+ }+ if (piped) {+ a[na] = *piped;+ }+ return he_apply(st, fr, fn, a, n);+}++static hv_t he_literal_int(hframe_t *fr, TSNode n) {+ size_t l = 0;+ const char *t = hn_text(fr, n, &l);+ char buf[CBM_SZ_64];+ size_t k = 0;+ for (size_t i = 0; i < l && k + SKIP_ONE < sizeof(buf); i++) {+ if (t[i] != '_') {+ buf[k++] = t[i];+ }+ }+ buf[k] = '\0';+ int base = 10;+ const char *p = buf;+ if (p[0] == '0' && (p[1] == 'o' || p[1] == 'O')) {+ base = 8;+ p += PAIR_LEN;+ } else if (p[0] == '0' && (p[1] == 'b' || p[1] == 'B')) {+ base = 2;+ p += PAIR_LEN;+ } else if (p[0] == '0' && (p[1] == 'x' || p[1] == 'X')) {+ base = 16;+ p += PAIR_LEN;+ } else if (p[0] == '0' && p[1]) {+ base = 8;+ p++;+ }+ char *end = NULL;+ long long v = strtoll(p, &end, base);+ return end && !*end ? hv_int(v) : HV_UNKNOWN;+}++static hv_t he_eval(hst_t *st, hframe_t *fr, TSNode n) {+ if (ts_node_is_null(n) || ts_node_has_error(n) || ts_node_is_missing(n)) {+ return HV_UNKNOWN;+ }+ const char *t = ts_node_type(n);+ size_t l = 0;+ if (strcmp(t, "dot") == 0) {+ return fr->dot;+ }+ if (strcmp(t, "field") == 0) {+ TSNode nm = hn_field(n, "name");+ if (ts_node_is_null(nm)) {+ return HV_UNKNOWN;+ }+ const char *name = hn_text(fr, nm, &l);+ return he_field(st, &fr->dot, name, l);+ }+ if (strcmp(t, "variable") == 0) {+ const char *name = hn_var_name(fr, n, &l);+ hvar_t *v = hst_var(st, fr, name, l);+ return v ? v->v : HV_UNKNOWN;+ }+ if (strcmp(t, "selector_expression") == 0) {+ TSNode op = hn_field(n, "operand");+ TSNode fd = hn_field(n, "field");+ if (ts_node_is_null(fd)) {+ return HV_UNKNOWN;+ }+ hv_t base = he_eval(st, fr, op);+ if (base.k == HV_UNK) {+ return HV_UNKNOWN;+ }+ const char *name = hn_text(fr, fd, &l);+ return he_field(st, &base, name, l);+ }+ if (strcmp(t, "chained_pipeline") == 0) {+ uint32_t c = ts_node_named_child_count(n);+ if (c == 0) {+ return HV_UNKNOWN;+ }+ hv_t v = he_eval(st, fr, ts_node_named_child(n, 0));+ for (uint32_t i = SKIP_ONE; i < c && v.k != HV_UNK; i++) {+ TSNode stage = ts_node_named_child(n, i);+ if (!hn_is(stage, "function_call") && !hn_is(stage, "identifier")) {+ return HV_UNKNOWN;+ }+ v = he_call(st, fr, stage, &v);+ }+ return v;+ }+ if (strcmp(t, "function_call") == 0 || strcmp(t, "identifier") == 0) {+ return he_call(st, fr, n, NULL);+ }+ if (strcmp(t, "parenthesized_pipeline") == 0) {+ return ts_node_named_child_count(n) == SKIP_ONE ? he_eval(st, fr, ts_node_named_child(n, 0))+ : HV_UNKNOWN;+ }+ if (strcmp(t, "interpreted_string_literal") == 0 || strcmp(t, "raw_string_literal") == 0) {+ const char *s = hn_text(fr, n, &l);+ char *out = cbm_arena_alloc(st->a, l * 4 + SKIP_ONE);+ size_t k = out ? hg_unquote(s, l, out) : (size_t)-1;+ if (k == (size_t)-1) {+ return HV_UNKNOWN;+ }+ out[k] = '\0';+ return hv_str(out, k);+ }+ if (strcmp(t, "int_literal") == 0) {+ return he_literal_int(fr, n);+ }+ if (strcmp(t, "float_literal") == 0) {+ const char *s = hn_text(fr, n, &l);+ char *buf = cbm_arena_strndup(st->a, s, l);+ return buf ? hv_float(strtod(buf, NULL)) : HV_UNKNOWN;+ }+ if (strcmp(t, "true") == 0 || strcmp(t, "false") == 0) {+ return hv_bool(t[0] == 't');+ }+ if (strcmp(t, "nil") == 0) {+ return hv_nil();+ }+ if (strcmp(t, "variable_definition") == 0 || strcmp(t, "assignment") == 0) {+ TSNode var = hn_field(n, "variable");+ hv_t v = he_eval(st, fr, hn_field(n, "value"));+ const char *name = ts_node_is_null(var) ? NULL : hn_var_name(fr, var, &l);+ if (!name) {+ return HV_UNKNOWN;+ }+ if (t[0] == 'v') {+ hst_var_push(st, name, l, v);+ } else {+ hvar_t *cur = hst_var(st, fr, name, l);+ if (!cur) {+ return HV_UNKNOWN;+ }+ cur->v = v;+ }+ return v;+ }+ return HV_UNKNOWN; /* method calls, rune / imaginary literals, ... */+}++/* ── Execution ────────────────────────────────────────────────────── */++static void he_item(hst_t *st, hframe_t *fr, TSNode c);++/* The named children of `parent` in field `field` (NULL: every one). */+static void he_items(hst_t *st, hframe_t *fr, TSNode parent, const char *field) {+ uint32_t cc = ts_node_child_count(parent);+ for (uint32_t i = 0; i < cc && !st->brk && !st->cont; i++) {+ TSNode c = ts_node_child(parent, i);+ if (!ts_node_is_named(c)) {+ continue;+ }+ const char *f = ts_node_field_name_for_child(parent, i);+ if (field ? !(f && strcmp(f, field) == 0) : f != NULL) {+ continue;+ }+ he_item(st, fr, c);+ }+}++/* if / else if / else, and with / else with: the first branch whose+ * condition holds runs; an UNKNOWN condition runs none. */+static void he_branches(hst_t *st, hframe_t *fr, TSNode n, bool with) {+ uint32_t cc = ts_node_child_count(n);+ bool taken = false;+ bool stop = false;+ bool active = false;+ int mark = st->nvars;+ hframe_t sub = *fr;+ for (uint32_t i = 0; i < cc && !st->brk && !st->cont; i++) {+ TSNode c = ts_node_child(n, i);+ if (!ts_node_is_named(c)) {+ continue;+ }+ const char *f = ts_node_field_name_for_child(n, i);+ if (!f) {+ continue;+ }+ if (strcmp(f, "condition") == 0) {+ if (taken || stop) {+ active = false;+ continue;+ }+ hv_t v = he_eval(st, fr, c);+ if (v.k == HV_UNK) {+ stop = true;+ active = false;+ hst_out_unknown(st, fr); /* which branch renders is unknown */+ continue;+ }+ active = hv_truth(&v);+ taken = active;+ sub = *fr;+ if (with && active) {+ sub.dot = v;+ }+ } else if (strcmp(f, "consequence") == 0 || strcmp(f, "option") == 0) {+ if (active) {+ he_item(st, &sub, c);+ }+ } else if (strcmp(f, "alternative") == 0) {+ if (!taken && !stop) {+ he_item(st, fr, c);+ }+ }+ }+ st->nvars = mark;+}++static void he_range(hst_t *st, hframe_t *fr, TSNode n) {+ TSNode def = {0};+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ if (hn_is(ts_node_named_child(n, i), "range_variable_definition")) {+ def = ts_node_named_child(n, i);+ }+ }+ TSNode expr = ts_node_is_null(def) ? hn_field(n, "range") : hn_field(def, "range");+ TSNode ivar = ts_node_is_null(def) ? (TSNode){0} : hn_field(def, "index");+ TSNode evar = ts_node_is_null(def) ? (TSNode){0} : hn_field(def, "element");+ if (!ts_node_is_null(ivar) && ts_node_is_null(evar)) {+ evar = ivar; /* range $x := ...: the element */+ ivar = (TSNode){0};+ }+ hv_t coll = he_eval(st, fr, expr);+ if (coll.k == HV_UNK) {+ hst_out_unknown(st, fr);+ return;+ }+ hv_t *items = NULL;+ const char **keys = NULL;+ int count = 0;+ bool is_map = hv_is_map(&coll);+ if (is_map) {+ count = hv_keys(st, &coll, &keys);+ } else if (coll.k == HV_INT) {+ count = coll.i > 0 ? (int)coll.i : 0;+ } else {+ count = hv_items(st, &coll, &items);+ }+ if (count < 0) {+ hst_out_unknown(st, fr);+ return;+ }+ size_t il = 0;+ size_t el = 0;+ const char *iname = ts_node_is_null(ivar) ? NULL : hn_var_name(fr, ivar, &il);+ const char *ename = ts_node_is_null(evar) ? NULL : hn_var_name(fr, evar, &el);+ for (int k = 0; k < count; k++) {+ int mark = st->nvars;+ hv_t elem;+ hv_t index;+ if (is_map) {+ elem = he_field(st, &coll, keys[k], strlen(keys[k]));+ index = hv_str(keys[k], strlen(keys[k]));+ } else if (coll.k == HV_INT) {+ elem = hv_int(k);+ index = hv_int(k);+ } else {+ elem = items[k];+ index = hv_int(k);+ }+ if (iname) {+ hst_var_push(st, iname, il, index);+ }+ if (ename) {+ hst_var_push(st, ename, el, elem);+ }+ hframe_t sub = *fr;+ sub.dot = elem;+ he_items(st, &sub, n, "body");+ st->nvars = mark;+ st->cont = false;+ if (st->brk) {+ st->brk = false;+ break;+ }+ }+ if (count == 0) {+ he_items(st, fr, n, "alternative");+ }+}++/* `template "name" arg` / a block: the define rendered into the output. */+static void he_template(hst_t *st, hframe_t *fr, TSNode n) {+ TSNode nm = hn_field(n, "name");+ TSNode arg = hn_field(n, "argument");+ size_t l = 0;+ const char *s = ts_node_is_null(nm) ? NULL : hn_text(fr, nm, &l);+ char *name = s ? cbm_arena_alloc(st->a, l * 4 + SKIP_ONE) : NULL;+ size_t k = name ? hg_unquote(s, l, name) : (size_t)-1;+ if (k == (size_t)-1) {+ hst_out_unknown(st, fr);+ return;+ }+ name[k] = '\0';+ hv_t a = ts_node_is_null(arg) ? hv_nil() : he_eval(st, fr, arg);+ if (a.k == HV_UNK) {+ hst_out_unknown(st, fr);+ return;+ }+ if (fr->out) {+ if (he_render_define(st, name, a, fr->out).k == HV_UNK) {+ fr->out->unk = true;+ }+ return;+ }+ /* at the top level the define's text is output that probes may read */+ hsink_t out = {0};+ if (he_render_define(st, name, a, &out).k == HV_UNK || out.unk) {+ hst_out_unknown(st, fr);+ return;+ }+ hst_out(st, fr, out.buf ? out.buf : "", out.n);+}++static void he_item(hst_t *st, hframe_t *fr, TSNode c) {+ const char *t = ts_node_type(c);+ if (strcmp(t, "text") == 0) {+ hst_text(st, fr, c);+ } else if (strcmp(t, "comment") == 0 || strcmp(t, "define_action") == 0) {+ return;+ } else if (strcmp(t, "if_action") == 0) {+ he_branches(st, fr, c, false);+ } else if (strcmp(t, "with_action") == 0) {+ he_branches(st, fr, c, true);+ } else if (strcmp(t, "range_action") == 0) {+ he_range(st, fr, c);+ } else if (strcmp(t, "template_action") == 0 || strcmp(t, "block_action") == 0) {+ he_template(st, fr, c);+ } else if (strcmp(t, "break_action") == 0) {+ st->brk = true;+ } else if (strcmp(t, "continue_action") == 0) {+ st->cont = true;+ } else if (strcmp(t, "variable_definition") == 0 || strcmp(t, "assignment") == 0) {+ (void)he_eval(st, fr, c);+ } else {+ hv_t v = he_eval(st, fr, c);+ if (v.k == HV_UNK) {+ hst_out_unknown(st, fr);+ } else {+ hst_out_value(st, fr, &v);+ }+ }+}++/* Define `name` rendered with dot / $ = arg into `into`. */+static hv_t he_render_define(hst_t *st, const char *name, hv_t arg, hsink_t *into) {+ const hd_def_t *d = hd_find(st->defs, name);+ if (!d || ++st->nesting > HELM_MAX_NESTING) {+ st->nesting -= d ? SKIP_ONE : 0;+ return HV_UNKNOWN;+ }+ int mark = st->nvars;+ hframe_t sub = {.src = d->file->src, .dot = arg, .var_base = st->nvars, .out = into};+ hst_var_push(st, "", 0, arg);+ bool brk = st->brk;+ bool cont = st->cont;+ st->brk = false;+ st->cont = false;+ he_items(st, &sub, d->node, "body");+ st->brk = brk;+ st->cont = cont;+ st->nvars = mark;+ st->nesting--;+ return into->unk ? HV_UNKNOWN : hv_nil();+}++/* ── Entry ────────────────────────────────────────────────────────── */++static hv_map_t *hv_struct(hst_t *st, int n) {+ hv_map_t *m = cbm_arena_calloc(st->a, sizeof(*m));+ if (m) {+ m->keys = cbm_arena_alloc(st->a, (size_t)n * sizeof(*m->keys));+ m->vals = cbm_arena_alloc(st->a, (size_t)n * sizeof(*m->vals));+ m->strict = true;+ if (!m->keys || !m->vals) {+ return NULL;+ }+ }+ return m;+}++static void hv_struct_set(hv_map_t *m, const char *k, hv_t v) {+ m->keys[m->n] = k;+ m->vals[m->n++] = v;+}++static hv_t hv_cstr(const char *s) {+ return s ? hv_str(s, strlen(s)) : hv_nil();+}++void cbm_helm_render(CBMArena *a, const char *rel, const char *src, size_t len,+ yyjson_mut_val *values, const cbm_helm_chart_meta_t *chart,+ const cbm_helm_defines_t *defs, cbm_helm_probe_t *probes, int nprobes) {+ (void)rel;+ for (int i = 0; i < nprobes; i++) {+ probes[i].n = 0;+ probes[i].image = NULL;+ probes[i].keys = NULL;+ }+ if (!src || nprobes == 0) {+ return;+ }+ hst_t st = {.a = a,+ .defs = defs,+ .top_src = src,+ .top_len = len,+ .probes = probes,+ .nprobes = nprobes,+ .capture = -SKIP_ONE};+ st.scratch = yyjson_mut_doc_new(cbm_json_writer_allocator());+ st.parser = ts_parser_new();+ if (!st.scratch || !st.parser ||+ !ts_parser_set_language(st.parser, cbm_ts_language(CBM_LANG_GOTEMPLATE))) {+ if (st.parser) {+ ts_parser_delete(st.parser);+ }+ if (st.scratch) {+ yyjson_mut_doc_free(st.scratch);+ }+ return;+ }+ int nl = SKIP_ONE;+ for (size_t i = 0; i < len; i++) {+ nl += src[i] == '\n';+ }+ uint32_t *lines = cbm_arena_alloc(a, (size_t)nl * sizeof(*lines));+ TSTree *tree = lines ? ts_parser_parse_string(st.parser, NULL, src, (uint32_t)len) : NULL;+ if (tree) {+ int k = 0;+ lines[k++] = 0;+ for (size_t i = 0; i < len; i++) {+ if (src[i] == '\n' && k < nl) {+ lines[k++] = (uint32_t)(i + SKIP_ONE);+ }+ }+ st.lines = lines;+ st.nlines = k;+ yyjson_mut_val *vals = values ? values : yyjson_mut_obj(st.scratch);+ hv_map_t *ch = hv_struct(&st, 3);+ hv_map_t *rl = hv_struct(&st, SKIP_ONE);+ hv_map_t *root = hv_struct(&st, PAIR_LEN + SKIP_ONE);+ if (ch && rl && root) {+ hv_struct_set(ch, "Name", hv_cstr(chart ? chart->name : NULL));+ hv_struct_set(ch, "Version", hv_cstr(chart ? chart->version : NULL));+ hv_struct_set(ch, "AppVersion", hv_cstr(chart ? chart->app_version : NULL));+ hv_struct_set(rl, "Service", hv_cstr("Helm"));+ hv_struct_set(root, "Values", hv_json(vals, ""));+ hv_struct_set(root, "Chart", (hv_t){.k = HV_MAP, .m = ch});+ hv_struct_set(root, "Release", (hv_t){.k = HV_MAP, .m = rl});+ hv_t dot = {.k = HV_MAP, .m = root};+ hframe_t fr = {.src = src, .dot = dot, .var_base = 0, .out = NULL};+ hst_var_push(&st, "", 0, dot);+ he_items(&st, &fr, ts_tree_root_node(tree), NULL);+ hst_capture_end(&st);+ }+ ts_tree_delete(tree);+ }+ for (int i = 0; i < st.ntrees; i++) {+ ts_tree_delete(st.trees[i]);+ }+ ts_parser_delete(st.parser);+ yyjson_mut_doc_free(st.scratch);+}diff --git a/src/pipeline/helm_template.h b/src/pipeline/helm_template.hnew file mode 100644index 000000000..ad24a6f78--- /dev/null+++ b/src/pipeline/helm_template.h@@ -0,0 +1,83 @@+/*+ * helm_template.h -- Helm values and the rendering of a chart template's+ * image references (pass_k8s.c). Internal to the pipeline.+ *+ * Values are JSON (yyjson mutable values), as Helm holds them after its+ * YAML -> JSON step: go-yaml v2 scalars (YAML 1.1 booleans), every number a+ * float64. A template renders with Go text/template semantics and the part+ * of Sprig image expressions use; anything else -- a function not modelled,+ * .Release / .Capabilities / lookup, a missing helper, a parse error on the+ * way -- is UNKNOWN, and an image that reads an UNKNOWN is no image. Nothing+ * is guessed: a value is what Helm would render, or none.+ */+#ifndef CBM_HELM_TEMPLATE_H+#define CBM_HELM_TEMPLATE_H++#include "foundation/arena.h"++#include "tree_sitter/api.h"+#include <yyjson/yyjson.h>++#include <stdbool.h>+#include <stddef.h>++/* The first document of YAML text src as a value of doc (Helm's scalar+ * types); NULL when it does not parse. An empty document is an empty map. */+yyjson_mut_val *cbm_helm_values_parse(yyjson_mut_doc *doc, const char *src, size_t len);++/* The YAML node `node` of text `src` (already parsed, e.g. a HelmRelease's+ * spec.values) as a value of doc; NULL when it holds an unknown part. */+yyjson_mut_val *cbm_helm_values_node(yyjson_mut_doc *doc, const char *src, TSNode node);++/* Helm's coalesce: a deep copy of `base` with `over` merged in -- maps merge+ * key by key, any other value replaces, a null deletes. Either may be NULL. */+yyjson_mut_val *cbm_helm_values_coalesce(yyjson_mut_doc *doc, yyjson_mut_val *base,+ yyjson_mut_val *over);++/* Helm --set NAME=VALUE into map `root`: NAME's `.` separates keys (`\.`+ * escapes one), `[n]` indexes a list; VALUE is typed like --set (int, bool,+ * null, else string) unless `as_string`. False when NAME is malformed. */+bool cbm_helm_values_set(yyjson_mut_doc *doc, yyjson_mut_val *root, const char *name,+ const char *value, bool as_string);++/* A values scalar as a template prints it (a number like Go's %v: 1.10 ->+ * 1.1) into out; false for a map, a list or null. */+bool cbm_helm_scalar_text(yyjson_mut_val *v, char *out, size_t sz);++/* A chart's metadata, as its templates see it under .Chart. */+typedef struct {+ const char *name;+ const char *version;+ const char *app_version;+} cbm_helm_chart_meta_t;++/* The named templates (`define` / `block`) of one chart family -- a chart and+ * the charts below it share one namespace; for one name the define of the+ * file nearest the family root wins (Helm loads deeper files first), then+ * the alphabetically first path. */+typedef struct cbm_helm_defines cbm_helm_defines_t;++cbm_helm_defines_t *cbm_helm_defines_new(void);+/* Register the defines of template file `rel` (text src, len). The text is+ * copied; its parse lives as long as the set. */+void cbm_helm_defines_add(cbm_helm_defines_t *d, const char *rel, const char *src, size_t len);+void cbm_helm_defines_free(cbm_helm_defines_t *d);++/* A probe: the `image:` key on a template line. Each time rendering passes+ * that line it captures the scalar written after the key. */+typedef struct {+ int line; /* 1-based line of the key in the template */+ int n; /* captures */+ const char **image; /* the rendered scalar, YAML quoting removed; NULL: UNKNOWN */+ const char **keys; /* JSON array of the values paths it read; NULL: none */+} cbm_helm_probe_t;++/* Render template `rel` (text src, len) with `values` (its .Values; NULL:+ * an empty map), `chart` and the family's defines, filling `probes` (strings+ * in arena a). Values paths are dot-joined keys, a key's own `.` escaped+ * (`\.`), as --set writes them. */+void cbm_helm_render(CBMArena *a, const char *rel, const char *src, size_t len,+ yyjson_mut_val *values, const cbm_helm_chart_meta_t *chart,+ const cbm_helm_defines_t *defs, cbm_helm_probe_t *probes, int nprobes);++#endif /* CBM_HELM_TEMPLATE_H */diff --git a/src/pipeline/pass_ci.c b/src/pipeline/pass_ci.cindex 2fc9e0912..a44a72c9c 100644--- a/src/pipeline/pass_ci.c+++ b/src/pipeline/pass_ci.c@@ -25,6 +25,7 @@*/#include "foundation/constants.h"#include "foundation/compat.h"+#include "foundation/str_util.h" /* cbm_json_escape */#include "pipeline/pipeline_internal.h"#include "cbm.h"#include "helpers.h" /* cbm_env_address */@@ -783,9 +784,33 @@ static const char *ci_env_lookup(const ci_env_t *env, const char *name, size_t nreturn NULL;}+/* JSON array `list` (NULL: empty) with identifier `name` appended once. */+static const char *ci_names_add(CBMArena *a, const char *list, const char *name, size_t nl) {+ if (!list) {+ return cbm_arena_sprintf(a, "[\"%.*s\"]", (int)nl, name);+ }+ char quoted[CBM_SZ_256];+ snprintf(quoted, sizeof(quoted), "\"%.*s\"", (int)nl, name);+ if (strstr(list, quoted)) {+ return list;+ }+ return cbm_arena_sprintf(a, "%.*s,%s]", (int)(strlen(list) - SKIP_ONE), list, quoted);+}++static const char *ci_interp_marks(CBMArena *a, const char *s, const ci_env_t *env,+ const char **dflt_of, const char **ovr_of);+/* `s` with ${X} / ${X:-d} / ${X-d} / $X expanded from env; NULL when a* variable has no value (and no default). */static const char *ci_interp(CBMArena *a, const char *s, const ci_env_t *env) {+ return ci_interp_marks(a, s, env, NULL, NULL);+}++/* ci_interp; `dflt_of` (may be NULL) gains, as a JSON array, the variables+ * whose inline default was used, `ovr_of` those with an inline default that+ * env set instead. */+static const char *ci_interp_marks(CBMArena *a, const char *s, const ci_env_t *env,+ const char **dflt_of, const char **ovr_of) {if (!s || !strchr(s, '$')) {return s;}@@ -839,6 +864,11 @@ static const char *ci_interp(CBMArena *a, const char *s, const ci_env_t *env) {}use = dflt;ul = dl;+ if (dflt_of) {+ *dflt_of = ci_names_add(a, *dflt_of, name, nl);+ }+ } else if (dflt && ovr_of) {+ *ovr_of = ci_names_add(a, *ovr_of, name, nl);}if (len + ul + SKIP_ONE > cap) {return NULL;@@ -1054,7 +1084,46 @@ static int ci_compose_env(const ci_t *c, TSNode svc, const ci_env_t *dotenv, conreturn k;}+/* A compose build's `args` (a mapping, or a list of "K=V" items), their+ * values interpolated, as a JSON object; NULL: none. An argument without a+ * value (the environment's) or with an unknown one is left out. */+static const char *ci_compose_build_args(const ci_t *c, TSNode build, const ci_env_t *env) {+ TSNode args = ts_node_is_null(build) ? build : ci_get(c, build, "args");+ if (ts_node_is_null(args)) {+ return NULL;+ }+ int n = 0;+ TSNode *items = ci_items(c, args, &n);+ ci_pair_t *pairs = items ? NULL : ci_pairs(c, args, &n);+ const char *json = NULL;+ for (int i = 0; i < n; i++) {+ const char *key = NULL;+ const char *raw = NULL;+ if (items) {+ const char *s = ci_scalar(c, items[i], NULL);+ const char *eq = s ? strchr(s, '=') : NULL;+ key = eq ? cbm_arena_strndup(c->a, s, (size_t)(eq - s)) : NULL;+ raw = eq ? eq + SKIP_ONE : NULL;+ } else {+ key = pairs[i].key;+ raw = ts_node_is_null(pairs[i].value) ? NULL : ci_scalar(c, pairs[i].value, NULL);+ }+ const char *value = raw ? ci_interp(c->a, raw, env) : NULL;+ if (!key || !key[0] || !value) {+ continue;+ }+ char ek[CBM_SZ_256];+ char ev[CBM_SZ_1K];+ cbm_json_escape(ek, (int)sizeof(ek), key);+ cbm_json_escape(ev, (int)sizeof(ev), value);+ json = cbm_arena_sprintf(c->a, "%s%s\"%s\":\"%s\"", json ? json : "{", json ? "," : "", ek,+ ev);+ }+ return json ? cbm_arena_sprintf(c->a, "%s}", json) : NULL;+}+static void ci_compose(const ci_t *c, TSNode root, const char *dir, const ci_env_t *env) {+ static const ci_env_t no_env = {0};int ns = 0;ci_pair_t *svcs = ci_pairs(c, ci_get(c, root, "services"), &ns);for (int i = 0; i < ns; i++) {@@ -1064,16 +1133,27 @@ static void ci_compose(const ci_t *c, TSNode root, const char *dir, const ci_env}int row = 0;const char *raw = ci_scalar(c, ci_get(c, svc, "image"), &row);- const char *image = raw ? ci_interp(c->a, raw, env) : NULL;- const char *df = ci_compose_dockerfile(c, ci_get(c, svc, "build"), dir, env);+ const char *dflt_of = NULL;+ const char *ovr_of = NULL;+ const char *image = raw ? ci_interp_marks(c->a, raw, env, &dflt_of, &ovr_of) : NULL;+ /* With .env replacing a default: what the defaults alone would name. */+ const char *default_image = image && ovr_of ? ci_interp(c->a, raw, &no_env) : NULL;+ TSNode build = ci_get(c, svc, "build");+ const char *df = ci_compose_dockerfile(c, build, dir, env);if (c->site_fn && image && df) {- cbm_build_site_t site = {- .via = "compose", .image = image, .dockerfile = df, .line = row + SKIP_ONE};+ cbm_build_site_t site = {.via = "compose",+ .image = image,+ .dockerfile = df,+ .build_args = ci_compose_build_args(c, build, env),+ .line = row + SKIP_ONE};c->site_fn(&site, c->ud);}if (c->service_fn) {cbm_compose_service_t s = {.name = svcs[i].key,.image = image,+ .image_default_of = image ? dflt_of : NULL,+ .image_override_of = image ? ovr_of : NULL,+ .default_image = default_image,.dockerfile = df,.line = (int)ts_node_start_point(svc).row,.end_line = (int)ts_node_end_point(svc).row + SKIP_ONE};diff --git a/src/pipeline/pass_docker.c b/src/pipeline/pass_docker.cindex f5f303866..5d2c2840d 100644--- a/src/pipeline/pass_docker.c+++ b/src/pipeline/pass_docker.c@@ -108,12 +108,31 @@ typedef struct {CBMHashTable *dirs; /* every directory holding a file (not the root) */} dk_index_t;+/* Where a value came from: the ARGs whose default (`dflt`) or build argument+ * (`ovr`) supplied part of it, as '\x1f'-separated names; NULL: none. */+typedef struct {+ const char *dflt;+ const char *ovr;+} dk_prov_t;+typedef struct dk_var {const char *name;const char *value; /* NULL: declared without a value */+ bool arg; /* an ARG: a build argument can set it */+ dk_prov_t prov;struct dk_var *next;} dk_var_t;+/* An image reference of FROM / COPY --from, linked once the file is read. */+typedef struct {+ int64_t img;+ const char *ref;+ const char *via;+ int stage;+ int line;+ dk_prov_t prov;+} dk_ref_t;+typedef struct {cbm_pipeline_ctx_t *ctx;CBMArena *a;@@ -131,6 +150,14 @@ typedef struct {dk_entry_t entry; /* the current stage's ENTRYPOINT */dk_entry_t cmd; /* the current stage's CMD */const dk_index_t *ix;+ dk_ref_t *refs; /* FROM / COPY --from references, in file order */+ int nrefs;+ int refs_cap;+ /* A build's view (dk_build_args): its build arguments set the ARGs they+ * name, and the references they change link from the Image it builds. */+ const dk_var_t *build_args;+ int64_t built; /* 0: the Dockerfile's own view */+ const char *build_props; /* the build's tool / file / build_line members */} dk_t;static bool dk_type(TSNode n, const char *t) {@@ -172,14 +199,72 @@ static const dk_var_t *dk_find(const dk_var_t *v, const char *name, size_t nl) {return NULL;}-static void dk_set(dk_t *d, dk_var_t **list, const char *name, const char *value) {+static void dk_set(dk_t *d, dk_var_t **list, const char *name, const char *value, bool arg,+ dk_prov_t prov) {dk_var_t *v = cbm_arena_alloc(d->a, sizeof(*v));if (v) {- *v = (dk_var_t){.name = name, .value = value, .next = *list};+ *v = (dk_var_t){.name = name, .value = value, .arg = arg, .prov = prov, .next = *list};*list = v;}}+enum { DK_NAME_SEP = '\x1f' };++static bool dk_names_has(const char *list, const char *name, size_t nl) {+ for (const char *p = list; p && *p;) {+ size_t l = strcspn(p, "\x1f");+ if (l == nl && strncmp(p, name, nl) == 0) {+ return true;+ }+ p += l;+ p += *p ? SKIP_ONE : 0;+ }+ return false;+}++/* `list` with `name` appended unless it holds it already. */+static const char *dk_names_add(dk_t *d, const char *list, const char *name, size_t nl) {+ if (dk_names_has(list, name, nl)) {+ return list;+ }+ return list && list[0] ? cbm_arena_sprintf(d->a, "%s%c%.*s", list, DK_NAME_SEP, (int)nl, name)+ : cbm_arena_strndup(d->a, name, nl);+}++static const char *dk_names_union(dk_t *d, const char *a, const char *b) {+ for (const char *p = b; p && *p;) {+ size_t l = strcspn(p, "\x1f");+ a = dk_names_add(d, a, p, l);+ p += l;+ p += *p ? SKIP_ONE : 0;+ }+ return a;+}++static void dk_prov_merge(dk_t *d, dk_prov_t *into, dk_prov_t from) {+ into->dflt = dk_names_union(d, into->dflt, from.dflt);+ into->ovr = dk_names_union(d, into->ovr, from.ovr);+}++/* `,"key":["A","B"]` for a non-empty name list, else "". */+static const char *dk_names_member(dk_t *d, const char *key, const char *list) {+ if (!list || !list[0]) {+ return "";+ }+ const char *out = cbm_arena_sprintf(d->a, ",\"%s\":[", key);+ for (const char *p = list; out && *p;) {+ size_t l = strcspn(p, "\x1f");+ char esc[CBM_SZ_256];+ char name[CBM_SZ_256];+ snprintf(name, sizeof(name), "%.*s", (int)l, p);+ cbm_json_escape(esc, (int)sizeof(esc), name);+ out = cbm_arena_sprintf(d->a, "%s%s\"%s\"", out, p == list ? "" : ",", esc);+ p += l;+ p += *p ? SKIP_ONE : 0;+ }+ return out ? cbm_arena_sprintf(d->a, "%s]", out) : "";+}+/* ASCII case-insensitive equality (stage names, `scratch`). */static bool dk_ieq(const char *a, const char *b) {for (; *a && *b; a++, b++) {@@ -195,8 +280,10 @@ static bool dk_name_char(char c) {}/* `text` with $X / ${X} / ${X:-d} / ${X-d} expanded from `vars`; NULL when a- * reference has no value. */-static const char *dk_expand(dk_t *d, const dk_var_t *vars, const char *text) {+ * reference has no value. `prov` (may be NULL) gains the ARGs whose default+ * or build argument supplied a value -- an inline `${X:-d}` default counts+ * only for a declared ARG X, the one thing a build argument can set. */+static const char *dk_expand(dk_t *d, const dk_var_t *vars, const char *text, dk_prov_t *prov) {size_t cap = strlen(text) + SKIP_ONE;size_t len = 0;char *out = cbm_arena_alloc(d->a, cap);@@ -249,6 +336,11 @@ static const char *dk_expand(dk_t *d, const dk_var_t *vars, const char *text) {return NULL;}const char *from = val ? val : dflt;+ if (prov && v && val) {+ dk_prov_merge(d, prov, v->prov);+ } else if (prov && v && v->arg) {+ prov->dflt = dk_names_add(d, prov->dflt, name, nl);+ }if (len + vl + SKIP_ONE > cap) {size_t ncap = (len + vl + SKIP_ONE) * PAIR_LEN;char *grown = cbm_arena_alloc(d->a, ncap);@@ -370,6 +462,139 @@ static int dk_stage_of(const dk_t *d, const char *ref) {return found;}+/* A path component: [a-z0-9]+ joined by `.`, `_`, `__` or `-`+. */+static bool dk_ref_component(const char *s, size_t n) {+ if (n == 0 || !isalnum((unsigned char)s[0]) || !isalnum((unsigned char)s[n - SKIP_ONE])) {+ return false;+ }+ for (size_t i = 0; i < n; i++) {+ unsigned char c = (unsigned char)s[i];+ if (isupper(c)) {+ return false;+ }+ if (isalnum(c)) {+ continue;+ }+ size_t run = SKIP_ONE;+ while (i + run < n && s[i + run] == c) {+ run++;+ }+ if (!((c == '.' && run == SKIP_ONE) || (c == '_' && run <= PAIR_LEN) || c == '-')) {+ return false;+ }+ i += run - SKIP_ONE;+ }+ return true;+}++/* A registry host: DNS labels (`.`-joined), or an IPv6 literal, with an+ * optional :port. */+static bool dk_ref_domain(const char *s, size_t n) {+ const char *colon = memchr(s, ':', n);+ if (n && s[0] == '[') {+ const char *close = memchr(s, ']', n);+ colon = close && (size_t)(close - s) + SKIP_ONE < n ? close + SKIP_ONE : NULL;+ if (!close) {+ return false;+ }+ }+ size_t hl = colon ? (size_t)(colon - s) : n;+ if (hl == 0) {+ return false;+ }+ if (s[0] != '[') {+ for (size_t i = 0; i < hl; i++) {+ unsigned char c = (unsigned char)s[i];+ if (!isalnum(c) && c != '.' && c != '-') {+ return false;+ }+ }+ }+ for (size_t i = hl + SKIP_ONE; colon && i < n; i++) {+ if (!isdigit((unsigned char)s[i])) {+ return false;+ }+ }+ return !colon || hl + SKIP_ONE < n;+}++bool cbm_image_ref_valid(const char *ref) {+ if (!ref || !ref[0]) {+ return false;+ }+ size_t n = strlen(ref);+ const char *at = strchr(ref, '@');+ if (at) {+ const char *colon = strchr(at, ':');+ if (!colon || colon == at + SKIP_ONE || strlen(colon + SKIP_ONE) < CBM_SZ_32) {+ return false;+ }+ for (const char *p = at + SKIP_ONE; p < colon; p++) {+ if (!isalnum((unsigned char)*p) && !strchr("+.-_", *p)) {+ return false;+ }+ }+ for (const char *p = colon + SKIP_ONE; *p; p++) {+ if (!isxdigit((unsigned char)*p)) {+ return false;+ }+ }+ n = (size_t)(at - ref);+ }+ /* the tag: after the last ':' that follows the last '/' */+ size_t name_end = n;+ for (size_t i = n; i > 0; i--) {+ if (ref[i - SKIP_ONE] == '/') {+ break;+ }+ if (ref[i - SKIP_ONE] == ':') {+ name_end = i - SKIP_ONE;+ break;+ }+ }+ if (name_end < n) {+ size_t tl = n - name_end - SKIP_ONE;+ const char *tag = ref + name_end + SKIP_ONE;+ if (tl == 0 || tl > CBM_SZ_128 || !(isalnum((unsigned char)tag[0]) || tag[0] == '_')) {+ return false;+ }+ for (size_t i = 0; i < tl; i++) {+ if (!isalnum((unsigned char)tag[i]) && !strchr("_.-", tag[i])) {+ return false;+ }+ }+ }+ const char *p = ref;+ const char *end = ref + name_end;+ const char *slash = memchr(p, '/', (size_t)(end - p));+ if (slash) {+ size_t fl = (size_t)(slash - p);+ bool host = memchr(p, '.', fl) || memchr(p, ':', fl) ||+ (fl == strlen("localhost") && memcmp(p, "localhost", fl) == 0);+ if (host) {+ if (!dk_ref_domain(p, fl)) {+ return false;+ }+ p = slash + SKIP_ONE;+ }+ }+ if (p >= end) {+ return false;+ }+ while (p < end) {+ const char *s = memchr(p, '/', (size_t)(end - p));+ size_t cl = s ? (size_t)(s - p) : (size_t)(end - p);+ if (!dk_ref_component(p, cl)) {+ return false;+ }+ p += cl + (s ? SKIP_ONE : 0);+ if (s && p >= end) {+ return false;+ }+ }+ return true;+}+int64_t cbm_pipeline_image_node(cbm_pipeline_ctx_t *ctx, const char *ref) {char repo[CBM_SZ_512];char reg[CBM_SZ_512];@@ -438,19 +663,101 @@ int64_t cbm_pipeline_env_setter(cbm_pipeline_ctx_t *ctx, const cbm_gbuf_node_t *return id;}-/* DEPENDS_ON from the Dockerfile to the Image of resolved reference `ref`. */-static void dk_link(dk_t *d, const char *ref, const char *via, int line) {+/* Record the Image of resolved reference `ref`, linked by dk_refs_link. */+static void dk_link(dk_t *d, const char *ref, const char *via, int line, dk_prov_t prov) {int64_t img = cbm_pipeline_image_node(d->ctx, ref);if (img <= 0) {return;}- char esc_ref[CBM_SZ_1K];- cbm_json_escape(esc_ref, (int)sizeof(esc_ref), ref);- char props[CBM_SZ_2K];- snprintf(props, sizeof(props), "{\"via\":\"%s\",\"image\":\"%s\",\"stage\":%d,\"line\":%d}",- via, esc_ref, d->stage, line);- cbm_gbuf_insert_edge(d->ctx->gbuf, d->module, img, "DEPENDS_ON", props);- d->edges++;+ if (d->nrefs == d->refs_cap) {+ int cap = d->refs_cap ? d->refs_cap * PAIR_LEN : DK_MAX_STAGES;+ dk_ref_t *grown = cbm_arena_alloc(d->a, (size_t)cap * sizeof(*grown));+ if (!grown) {+ return;+ }+ if (d->nrefs) {+ memcpy(grown, d->refs, (size_t)d->nrefs * sizeof(*grown));+ }+ d->refs = grown;+ d->refs_cap = cap;+ }+ d->refs[d->nrefs++] = (dk_ref_t){img, ref, via, d->stage, line, prov};+}++/* The names a default supplies to the references of Image `img`: their union,+ * or NULL when any of them names it without a default (a literal reference+ * wins -- the edges to one Image are one edge, so every one of them carries+ * the same mark). */+static const char *dk_refs_defaults(dk_t *d, int64_t img) {+ const char *names = NULL;+ for (int i = 0; i < d->nrefs; i++) {+ if (d->refs[i].img != img) {+ continue;+ }+ if (!d->refs[i].prov.dflt) {+ return NULL;+ }+ names = dk_names_union(d, names, d->refs[i].prov.dflt);+ }+ return names;+}++/* The Dockerfile's own view: DEPENDS_ON from its Module to each Image FROM /+ * COPY --from names {via, image, stage, line[, default_of: the ARGs whose+ * defaults named it]}. */+static void dk_refs_link(dk_t *d) {+ for (int i = 0; i < d->nrefs; i++) {+ const dk_ref_t *r = &d->refs[i];+ char esc_ref[CBM_SZ_1K];+ cbm_json_escape(esc_ref, (int)sizeof(esc_ref), r->ref);+ const char *dflt = dk_names_member(d, "default_of", dk_refs_defaults(d, r->img));+ const char *props =+ cbm_arena_sprintf(d->a, "{\"via\":\"%s\",\"image\":\"%s\",\"stage\":%d,\"line\":%d%s}",+ r->via, esc_ref, r->stage, r->line, dflt);+ if (props) {+ cbm_gbuf_insert_edge(d->ctx->gbuf, d->module, r->img, "DEPENDS_ON", props);+ d->edges++;+ }+ }+}++/* A build's view: each Image a reference the build's arguments changed names+ * -- the first reference to it, its build arguments unioned --+ * DEPENDS_ON from the Image the build makes {via, image, override_of[,+ * default_of], dockerfile, stage, line, tool, file, build_line}. A reference+ * no build argument reached is the Dockerfile's own edge already. */+static void dk_refs_link_build(dk_t *d) {+ for (int i = 0; i < d->nrefs; i++) {+ const dk_ref_t *r = &d->refs[i];+ bool first = r->prov.ovr != NULL && r->img != d->built;+ for (int j = 0; first && j < i; j++) {+ first = !(d->refs[j].img == r->img && d->refs[j].prov.ovr);+ }+ if (!first) {+ continue;+ }+ dk_prov_t all = {0};+ for (int j = i; j < d->nrefs; j++) {+ if (d->refs[j].img == r->img && d->refs[j].prov.ovr) {+ dk_prov_merge(d, &all, d->refs[j].prov);+ }+ }+ char esc_ref[CBM_SZ_1K];+ char esc_file[CBM_SZ_1K];+ cbm_json_escape(esc_ref, (int)sizeof(esc_ref), r->ref);+ cbm_json_escape(esc_file, (int)sizeof(esc_file), d->file);+ const char *props = cbm_arena_sprintf(+ d->a,+ "{\"via\":\"%s\",\"image\":\"%s\"%s%s,\"dockerfile\":\"%s\",\"stage\":%d,"+ "\"line\":%d,%s}",+ r->via, esc_ref, dk_names_member(d, "override_of", all.ovr),+ dk_names_member(d, "default_of", all.dflt), esc_file, r->stage, r->line,+ d->build_props);+ if (props) {+ cbm_gbuf_insert_edge(d->ctx->gbuf, d->built, r->img, "DEPENDS_ON", props);+ d->edges++;+ }+ }}static int dk_line(TSNode n) {@@ -467,19 +774,33 @@ static void dk_arg(dk_t *d, TSNode ins) {if (!name) {return;}- if (d->stage < 0) {- dk_set(d, &d->global, name, ts_node_is_null(df) ? NULL : dk_value(d, df));+ size_t nl = strlen(name);+ dk_var_t **list = d->stage < 0 ? &d->global : &d->local;+ /* A build argument sets the ARG it names, in every stage declaring it,+ * whatever its default. */+ const dk_var_t *set = dk_find(d->build_args, name, nl);+ if (set) {+ dk_set(d, list, name, set->value, true,+ (dk_prov_t){.ovr = dk_names_add(d, NULL, name, nl)});return;}const char *value = NULL;+ dk_prov_t prov = {0};if (!ts_node_is_null(df)) {+ /* A default may name ARGs declared before it (ARG BASE=golang:${GO}). */const char *raw = dk_value(d, df);- value = raw ? dk_expand(d, d->local, raw) : NULL;- } else {- const dk_var_t *g = dk_find(d->global, name, strlen(name));- value = g ? g->value : NULL;+ value = raw ? dk_expand(d, *list, raw, &prov) : NULL;+ if (value) {+ prov.dflt = dk_names_add(d, prov.dflt, name, nl);+ }+ } else if (d->stage >= 0) {+ const dk_var_t *g = dk_find(d->global, name, nl);+ if (g) {+ value = g->value;+ prov = g->prov;+ }}- dk_set(d, &d->local, name, value);+ dk_set(d, list, name, value, true, prov);}static void dk_env(dk_t *d, TSNode ins) {@@ -498,7 +819,9 @@ static void dk_env(dk_t *d, TSNode ins) {}const char *raw = ts_node_is_null(vl) ? NULL : dk_value(d, vl);const char *name = dk_text(d, nm);- dk_set(d, &d->local, name, raw ? dk_expand(d, d->local, raw) : NULL);+ dk_prov_t prov = {0};+ const char *value = raw ? dk_expand(d, d->local, raw, &prov) : NULL;+ dk_set(d, &d->local, name, value, false, prov);dk_envkey_t *k = d->stage < DK_MAX_STAGES ? cbm_arena_alloc(d->a, sizeof(*k)) : NULL;if (k && name) {*k = (dk_envkey_t){name, dk_line(pair), d->st[d->stage].envs};@@ -515,7 +838,9 @@ static void dk_from(dk_t *d, TSNode ins) {spec = ts_node_named_child(ins, i);}}- const char *ref = ts_node_is_null(spec) ? NULL : dk_expand(d, d->global, dk_text(d, spec));+ dk_prov_t prov = {0};+ const char *ref =+ ts_node_is_null(spec) ? NULL : dk_expand(d, d->global, dk_text(d, spec), &prov);d->stage++;d->local = NULL;d->workdir = "/";@@ -523,7 +848,7 @@ static void dk_from(dk_t *d, TSNode ins) {d->cmd.set = false;bool stage = ref && dk_is_stage(d, ref);if (ref && !stage) {- dk_link(d, ref, "from", dk_line(ins));+ dk_link(d, ref, "from", dk_line(ins), prov);}if (d->stage < DK_MAX_STAGES) {d->st[d->stage].parent = stage ? dk_stage_of(d, ref) : -1;@@ -605,7 +930,7 @@ static int dk_copy_json(dk_t *d, const char *p, const char **out, int max) {if (yyjson_is_arr(arr)) {for (yyjson_arr_iter_init(arr, &it); n < max && (v = yyjson_arr_iter_next(&it));) {const char *s = yyjson_get_str(v);- out[n++] = s ? dk_expand(d, d->local, cbm_arena_strdup(d->a, s)) : NULL;+ out[n++] = s ? dk_expand(d, d->local, cbm_arena_strdup(d->a, s), NULL) : NULL;}}if (doc) {@@ -639,11 +964,12 @@ static void dk_copy(dk_t *d, TSNode ins) {if (l > sizeof(FROM) - SKIP_ONE && strncmp(p, FROM, sizeof(FROM) - SKIP_ONE) == 0) {const char *v =cbm_arena_strndup(d->a, p + sizeof(FROM) - SKIP_ONE, l - (sizeof(FROM) - SKIP_ONE));- const char *ref = v ? dk_expand(d, d->local, v) : NULL;+ dk_prov_t prov = {0};+ const char *ref = v ? dk_expand(d, d->local, v, &prov) : NULL;c->has_from = true;c->from = ref;if (ref && ref[0] && !dk_is_stage(d, ref)) {- dk_link(d, ref, "copy-from", dk_line(ins));+ dk_link(d, ref, "copy-from", dk_line(ins), prov);}}p += l;@@ -652,7 +978,7 @@ static void dk_copy(dk_t *d, TSNode ins) {while (!json && *p && nw < DK_MAX_WORDS) {size_t l = strcspn(p, " \t");const char *w = cbm_arena_strndup(d->a, p, l);- words[nw++] = w && strncmp(w, "<<", PAIR_LEN) != 0 ? dk_expand(d, d->local, w) : NULL;+ words[nw++] = w && strncmp(w, "<<", PAIR_LEN) != 0 ? dk_expand(d, d->local, w, NULL) : NULL;p += l;p += strspn(p, " \t");}@@ -1023,8 +1349,8 @@ static void dk_go_builds(dk_t *d, const char **w, int n) {if (!b) {return;}- *b = (dk_build_t){.out = out ? dk_expand(d, d->local, out) : NULL,- .pkg = dk_expand(d, d->local, pkg ? pkg : "."),+ *b = (dk_build_t){.out = out ? dk_expand(d, d->local, out, NULL) : NULL,+ .pkg = dk_expand(d, d->local, pkg ? pkg : ".", NULL),.workdir = d->workdir,.next = d->st[d->stage].builds};d->st[d->stage].builds = b;@@ -1066,7 +1392,7 @@ static void dk_workdir(dk_t *d, TSNode ins) {continue;}const char *raw = dk_text(d, pn);- const char *v = raw ? dk_expand(d, d->local, raw) : NULL;+ const char *v = raw ? dk_expand(d, d->local, raw, NULL) : NULL;const char *w = v ? v : raw;if (w) {d->workdir = dk_absolute(d, w, d->workdir);@@ -1431,11 +1757,31 @@ static void dk_file(dk_t *d, TSNode root) {dk_entry(d, ins, &d->cmd);}}+ dk_refs_link(d);dk_spawn(d);dk_envs(d);dk_image_set(d);}+/* A build's view of the Dockerfile: only what decides its image references+ * (ARG, ENV, FROM, COPY --from) is read, under the build's arguments. */+static void dk_file_build(dk_t *d, TSNode root) {+ for (uint32_t i = 0; i < ts_node_named_child_count(root); i++) {+ TSNode ins = ts_node_named_child(root, i);+ if (dk_type(ins, "arg_instruction")) {+ dk_arg(d, ins);+ } else if (dk_type(ins, "env_instruction")) {+ dk_env(d, ins);+ } else if (dk_type(ins, "from_instruction")) {+ dk_from(d, ins);+ } else if ((dk_type(ins, "copy_instruction") || dk_type(ins, "add_instruction")) &&+ d->stage >= 0) {+ dk_copy(d, ins);+ }+ }+ dk_refs_link_build(d);+}+static char *dk_read(const char *path, size_t *len) {FILE *f = cbm_fopen(path, "rb");if (!f) {@@ -1545,12 +1891,15 @@ static void dk_build_site(const cbm_build_site_t *s, void *ud) {char esc_img[CBM_SZ_1K];cbm_json_escape(esc_file, (int)sizeof(esc_file), b->file);cbm_json_escape(esc_img, (int)sizeof(esc_img), s->image);- char props[CBM_SZ_4K];- snprintf(props, sizeof(props),- "{\"via\":\"build\",\"tool\":\"%s\",\"file\":\"%s\",\"image\":\"%s\",\"line\":%d}",- s->via, esc_file, esc_img, s->line);- cbm_gbuf_insert_edge(b->ctx->gbuf, img, mod->id, "DEPENDS_ON", props);- b->edges++;+ const char *props = cbm_arena_sprintf(+ b->a,+ "{\"via\":\"build\",\"tool\":\"%s\",\"file\":\"%s\",\"image\":\"%s\",\"line\":%d%s%s}",+ s->via, esc_file, esc_img, s->line, s->build_args ? ",\"build_args\":" : "",+ s->build_args ? s->build_args : "");+ if (props) {+ cbm_gbuf_insert_edge(b->ctx->gbuf, img, mod->id, "DEPENDS_ON", props);+ b->edges++;+ }}typedef struct {@@ -1599,6 +1948,41 @@ static void dk_compose_connects(dk_compose_t *c, const cbm_compose_service_t *s,* DEFINES; it DEPENDS_ON the services it depends on / links, USAGE* {ref:image} its image, DEPENDS_ON {via:build} the Dockerfile it builds and* CONNECTS_TO the services its environment addresses. */+/* The image a service runs: USAGE {ref: image, image[, default_of]} -- the+ * variables whose inline default named it. When the project's .env replaced+ * a default, the edge carries {override_of, override_source: ".env"}, and+ * the image the defaults alone name is kept: on the same Image as+ * `default_image`, else its own USAGE {ref: image_default, default_of}, a+ * reference the service does not run. */+static void dk_compose_image(dk_compose_t *c, const cbm_compose_service_t *s, int64_t self) {+ int64_t img = cbm_pipeline_image_node(c->ctx, s->image);+ int64_t dimg = s->default_image ? cbm_pipeline_image_node(c->ctx, s->default_image) : 0;+ char esc[CBM_SZ_1K];+ char desc[CBM_SZ_1K];+ cbm_json_escape(esc, (int)sizeof(esc), s->image);+ cbm_json_escape(desc, (int)sizeof(desc), s->default_image ? s->default_image : "");+ const char *props =+ cbm_arena_sprintf(c->a, "{\"ref\":\"image\",\"image\":\"%s\"%s%s%s%s%s%s%s}", esc,+ s->image_default_of ? ",\"default_of\":" : "",+ s->image_default_of ? s->image_default_of : "",+ s->image_override_of ? ",\"override_of\":" : "",+ s->image_override_of ? s->image_override_of : "",+ s->image_override_of ? ",\"override_source\":\".env\"" : "",+ dimg > 0 && dimg == img ? ",\"default_image\":\"" : "",+ dimg > 0 && dimg == img ? cbm_arena_sprintf(c->a, "%s\"", desc) : "");+ if (props) {+ dk_compose_edge(c, self, img, "USAGE", props);+ }+ if (dimg > 0 && dimg != img && s->image_override_of) {+ const char *dprops = cbm_arena_sprintf(+ c->a, "{\"ref\":\"image_default\",\"image\":\"%s\",\"default_of\":%s}", desc,+ s->image_override_of);+ if (dprops) {+ dk_compose_edge(c, self, dimg, "USAGE", dprops);+ }+ }+}+static void dk_compose_service(const cbm_compose_service_t *s, void *ud) {dk_compose_t *c = ud;const char *qn = dk_compose_qn(c, s->name);@@ -1635,11 +2019,7 @@ static void dk_compose_service(const cbm_compose_service_t *s, void *ud) {}dk_compose_connects(c, s, self->id);if (s->image) {- char esc[CBM_SZ_1K];- cbm_json_escape(esc, (int)sizeof(esc), s->image);- char props[CBM_SZ_2K];- snprintf(props, sizeof(props), "{\"ref\":\"image\",\"image\":\"%s\"}", esc);- dk_compose_edge(c, self->id, cbm_pipeline_image_node(c->ctx, s->image), "USAGE", props);+ dk_compose_image(c, s, self->id);}if (s->dockerfile) {const char *mqn = cbm_fqn_module(c->a, c->ctx->project_name, s->dockerfile);@@ -1706,6 +2086,152 @@ static int dk_link_builds(cbm_pipeline_ctx_t *ctx, CBMArena *a) {return b.edges;}+static bool dk_prop(const char *props, const char *key, char *out, size_t out_sz);+static void *dk_grow(CBMArena *a, void *v, int n, int *cap, size_t size);++/* A build that passes build arguments (compose build.args, docker build+ * --build-arg; on its build edge as `build_args`). */+typedef struct {+ int64_t img;+ int64_t module;+ const char *dockerfile;+ const dk_var_t *args;+ const char *props; /* "tool":..,"file":..,"build_line":N */+} dk_argbuild_t;++/* The build arguments of build edge properties `props` (NULL: none). */+static const dk_var_t *dk_build_args_of(CBMArena *a, const char *props) {+ if (!props || !strstr(props, "\"build_args\"")) {+ return NULL;+ }+ yyjson_doc *doc = yyjson_read(props, strlen(props), 0);+ yyjson_val *args = doc ? yyjson_obj_get(yyjson_doc_get_root(doc), "build_args") : NULL;+ dk_var_t *list = NULL;+ yyjson_obj_iter it;+ yyjson_val *k;+ if (yyjson_is_obj(args)) {+ yyjson_obj_iter_init(args, &it);+ while ((k = yyjson_obj_iter_next(&it))) {+ const char *v = yyjson_get_str(yyjson_obj_iter_get_val(k));+ dk_var_t *var = v ? cbm_arena_alloc(a, sizeof(*var)) : NULL;+ if (var) {+ *var = (dk_var_t){.name = cbm_arena_strdup(a, yyjson_get_str(k)),+ .value = cbm_arena_strdup(a, v),+ .arg = true,+ .next = list};+ list = var;+ }+ }+ }+ if (doc) {+ yyjson_doc_free(doc);+ }+ return list;+}++/* Every build edge (Image -DEPENDS_ON {via: build}-> Dockerfile) that passes+ * build arguments, into out (arena); returns how many. */+static int dk_argbuilds(cbm_pipeline_ctx_t *ctx, CBMArena *a, dk_argbuild_t **out) {+ const cbm_gbuf_node_t **imgs = NULL;+ int ni = 0;+ *out = NULL;+ if (cbm_gbuf_find_by_label(ctx->gbuf, "Image", &imgs, &ni) != 0) {+ return 0;+ }+ int n = 0;+ int cap = 0;+ for (int i = 0; i < ni; i++) {+ const cbm_gbuf_edge_t **es = NULL;+ int ne = 0;+ if (cbm_gbuf_find_edges_by_source_type(ctx->gbuf, imgs[i]->id, "DEPENDS_ON", &es, &ne) !=+ 0) {+ continue;+ }+ for (int j = 0; j < ne; j++) {+ const char *p = es[j]->properties_json;+ char via[CBM_SZ_32];+ const dk_var_t *args = NULL;+ if (!dk_prop(p, "via", via, sizeof(via)) || strcmp(via, "build") != 0 ||+ !(args = dk_build_args_of(a, p))) {+ continue;+ }+ const cbm_gbuf_node_t *mod = cbm_gbuf_find_by_id(ctx->gbuf, es[j]->target_id);+ char tool[CBM_SZ_64];+ char file[CBM_SZ_1K];+ char esc[CBM_SZ_2K];+ if (!mod || !mod->file_path || !dk_prop(p, "tool", tool, sizeof(tool)) ||+ !dk_prop(p, "file", file, sizeof(file))) {+ continue;+ }+ const char *line = strstr(p, "\"line\":");+ if (n == cap) {+ *out = dk_grow(a, *out, n, &cap, sizeof(**out));+ if (!*out) {+ return 0;+ }+ }+ cbm_json_escape(esc, (int)sizeof(esc), file);+ (*out)[n++] = (dk_argbuild_t){+ .img = imgs[i]->id,+ .module = mod->id,+ .dockerfile = cbm_arena_strdup(a, mod->file_path),+ .args = args,+ .props = cbm_arena_sprintf(a, "\"tool\":\"%s\",\"file\":\"%s\",\"build_line\":%d",+ tool, esc, line ? atoi(line + strlen("\"line\":")) : 0)};+ }+ }+ return n;+}++/* Each build passing build arguments reads its Dockerfile in its own view+ * (dk_file_build): what those arguments change, it builds FROM. Image-sourced+ * DEPENDS_ON edges, recomputed whole every run (CBM_BUILD_EDGE_SOURCE). */+static int dk_link_build_args(cbm_pipeline_ctx_t *ctx, CBMArena *a) {+ dk_argbuild_t *bs = NULL;+ int n = ctx->repo_path ? dk_argbuilds(ctx, a, &bs) : 0;+ if (n == 0) {+ return 0;+ }+ TSParser *parser = ts_parser_new();+ if (!parser || !ts_parser_set_language(parser, cbm_ts_language(CBM_LANG_DOCKERFILE))) {+ if (parser) {+ ts_parser_delete(parser);+ }+ return 0;+ }+ int edges = 0;+ for (int i = 0; i < n; i++) {+ char path[CBM_SZ_4K];+ snprintf(path, sizeof(path), "%s/%s", ctx->repo_path, bs[i].dockerfile);+ size_t len = 0;+ char *src = dk_read(path, &len);+ if (!src) {+ continue;+ }+ dk_uncomment(src, len);+ TSTree *tree = ts_parser_parse_string(parser, NULL, src, (uint32_t)len);+ if (tree) {+ dk_t d = {.ctx = ctx,+ .a = a,+ .src = src,+ .file = bs[i].dockerfile,+ .module = bs[i].module,+ .stage = -1,+ .dir = "",+ .workdir = "/",+ .build_args = bs[i].args,+ .built = bs[i].img,+ .build_props = bs[i].props};+ dk_file_build(&d, ts_tree_root_node(tree));+ edges += d.edges;+ ts_tree_delete(tree);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ }+ ts_parser_delete(parser);+ return edges;+}+static bool dk_node_before(const cbm_gbuf_node_t *a, const cbm_gbuf_node_t *b) {int c = strcmp(a->file_path, b->file_path);return c < 0 || (c == 0 && a->start_line < b->start_line);@@ -1891,17 +2417,19 @@ static void dk_hub_push(CBMArena *a, dk_hub_edges_t *l, const cbm_gbuf_edge_t *e* USAGE {ref:image}, or DEPENDS_ON {via:from|copy-from}? */static bool dk_hub_ref(const char *type, const char *p) {char v[CBM_SZ_32];- if (strcmp(type, "USAGE") == 0) {+ if (strcmp(type, "USAGE") == 0 || strcmp(type, "DEPLOYS") == 0) {return dk_prop(p, "ref", v, sizeof(v)) && strcmp(v, "image") == 0;}return dk_prop(p, "via", v, sizeof(v)) &&(strcmp(v, "from") == 0 || strcmp(v, "copy-from") == 0);}-/* The edges of Image `img`: build edges out (DEPENDS_ON {via:build}) and- * references in, each with the tag of its `image` reference. */+/* The edges of Image `img`: build edges out (DEPENDS_ON {via:build}), the+ * base images a build's arguments chose out (DEPENDS_ON {via: from |+ * copy-from, build_line}: they follow their build) and references in, each+ * with the tag of its `image` reference. */static void dk_hub_collect(cbm_pipeline_ctx_t *ctx, CBMArena *a, int64_t img,- dk_hub_edges_t *builds, dk_hub_edges_t *refs) {+ dk_hub_edges_t *builds, dk_hub_edges_t *refs, dk_hub_edges_t *follows) {const cbm_gbuf_edge_t **es = NULL;int n = 0;char ref[CBM_SZ_1K];@@ -1909,8 +2437,13 @@ static void dk_hub_collect(cbm_pipeline_ctx_t *ctx, CBMArena *a, int64_t img,if (cbm_gbuf_find_edges_by_source_type(ctx->gbuf, img, "DEPENDS_ON", &es, &n) == 0) {for (int i = 0; i < n; i++) {char via[CBM_SZ_32];- if (!dk_prop(es[i]->properties_json, "via", via, sizeof(via)) ||- strcmp(via, "build") != 0) {+ if (!dk_prop(es[i]->properties_json, "via", via, sizeof(via))) {+ continue;+ }+ if (strcmp(via, "build") != 0) {+ if (strstr(es[i]->properties_json, "\"build_line\":")) {+ dk_hub_push(a, follows, es[i], "");+ }continue;}tag[0] = '\0';@@ -1921,7 +2454,7 @@ static void dk_hub_collect(cbm_pipeline_ctx_t *ctx, CBMArena *a, int64_t img,}atomic_fetch_add_explicit(&g_dk_hub_edges, (uint64_t)n, memory_order_relaxed);}- static const char *const REF_TYPES[] = {"USAGE", "DEPENDS_ON"};+ static const char *const REF_TYPES[] = {"USAGE", "DEPENDS_ON", "DEPLOYS"};for (size_t t = 0; t < sizeof(REF_TYPES) / sizeof(REF_TYPES[0]); t++) {if (cbm_gbuf_find_edges_by_target_type(ctx->gbuf, img, REF_TYPES[t], &es, &n) != 0) {continue;@@ -2122,6 +2655,27 @@ static int dk_hub_move(cbm_pipeline_ctx_t *ctx, CBMArena *a, const dk_hub_edge_treturn SKIP_ONE;}+static int dk_prop_int(const char *props, const char *key) {+ char pat[CBM_SZ_64];+ snprintf(pat, sizeof(pat), "\"%s\":", key);+ const char *p = props ? strstr(props, pat) : NULL;+ return p ? atoi(p + strlen(pat)) : -SKIP_ONE;+}++/* Does base-image edge `f` come from build edge `b`: one source, and its+ * tool / file / build_line those of the build? */+static bool dk_hub_follows(const dk_hub_edge_t *f, const dk_hub_edge_t *b) {+ char ft[CBM_SZ_64];+ char bt[CBM_SZ_64];+ char ff[CBM_SZ_1K];+ char bf[CBM_SZ_1K];+ return f->src == b->src && dk_prop(f->props, "tool", ft, sizeof(ft)) &&+ dk_prop(b->props, "tool", bt, sizeof(bt)) && strcmp(ft, bt) == 0 &&+ dk_prop(f->props, "file", ff, sizeof(ff)) && dk_prop(b->props, "file", bf, sizeof(bf)) &&+ strcmp(ff, bf) == 0 &&+ dk_prop_int(f->props, "build_line") == dk_prop_int(b->props, "line");+}+/* One repository's Images (imgs[0..n)): split it by component when it is* built from several Dockerfiles, else keep (or bring back) everything on* the repository Image. Returns the edges moved. */@@ -2129,10 +2683,11 @@ static int dk_hub_repo(cbm_pipeline_ctx_t *ctx, CBMArena *a, const dk_img_t *imgdk_drop_t *drop) {dk_hub_edges_t builds = {0};dk_hub_edges_t refs = {0};+ dk_hub_edges_t follows = {0};bool has_sub = false;for (int i = 0; i < n; i++) {has_sub = has_sub || strcmp(imgs[i].name, imgs[i].repo) != 0;- dk_hub_collect(ctx, a, imgs[i].id, &builds, &refs);+ dk_hub_collect(ctx, a, imgs[i].id, &builds, &refs, &follows);}const char **comps = NULL;size_t pre = 0;@@ -2158,6 +2713,11 @@ static int dk_hub_repo(cbm_pipeline_ctx_t *ctx, CBMArena *a, const dk_img_t *imgint k = builds.v[i].comp;int64_t src = sub && k >= 0 && sub[k] > 0 ? sub[k] : repo_img;moved += dk_hub_move(ctx, a, &builds.v[i], src, builds.v[i].tgt, drop);+ for (int f = 0; f < follows.n; f++) {+ if (dk_hub_follows(&follows.v[f], &builds.v[i])) {+ moved += dk_hub_move(ctx, a, &follows.v[f], src, follows.v[f].tgt, drop);+ }+ }}for (int i = 0; i < refs.n; i++) {int k = sub ? dk_hub_match(refs.v[i].tag, comps, nc) : -1;@@ -2274,6 +2834,7 @@ void cbm_pipeline_pass_docker(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *ficbm_ht_free(ix.dirs);}edges += dk_link_builds(ctx, &arena);+ edges += dk_link_build_args(ctx, &arena);edges += dk_image_hubs(ctx, &arena);cbm_arena_destroy(&arena);if (edges > 0) {diff --git a/src/pipeline/pass_k8s.c b/src/pipeline/pass_k8s.cindex a9e92acc7..60433514c 100644--- a/src/pipeline/pass_k8s.c+++ b/src/pipeline/pass_k8s.c@@ -20,10 +20,12 @@#include "foundation/compat_fs.h"#include "foundation/limits.h"#include "cbm.h"-#include "helpers.h" /* cbm_kind_in_set_free_cache */-#include "foundation/slab_alloc.h" /* cbm_slab_destroy_thread */-#include "foundation/platform.h" /* cbm_default_worker_count */-#include "foundation/str_util.h" /* cbm_json_escape */+#include "helpers.h" /* cbm_kind_in_set_free_cache */+#include "foundation/slab_alloc.h" /* cbm_slab_destroy_thread */+#include "foundation/platform.h" /* cbm_default_worker_count */+#include "foundation/str_util.h" /* cbm_json_escape */+#include "foundation/json_writer.h" /* cbm_json_writer_allocator */+#include "pipeline/helm_template.h"#include "pipeline/worker_pool.h"#include <ctype.h>@@ -1103,9 +1105,7 @@ static void k8s_bundles_free(k8s_bundles_t *b) {}/* A Helm chart's directory bundles the plain manifests below it. */-static void k8s_chart_dir_add(k8s_bundles_t *b, const char *chart_yaml) {- char dir[CBM_SZ_1K];- k8s_dirname(chart_yaml, dir, sizeof(dir));+static void k8s_chart_dir_register(k8s_bundles_t *b, const char *dir) {if (b->charts && !cbm_ht_get(b->charts, dir)) {char *owned = cbm_mem_strdup(CBM_MEM_CLASS_OTHER, dir);if (owned) {@@ -1114,6 +1114,12 @@ static void k8s_chart_dir_add(k8s_bundles_t *b, const char *chart_yaml) {}}+static void k8s_chart_dir_add(k8s_bundles_t *b, const char *chart_yaml) {+ char dir[CBM_SZ_1K];+ k8s_dirname(chart_yaml, dir, sizeof(dir));+ k8s_chart_dir_register(b, dir);+}+/* Build the kustomize bundles (call once every manifest and kustomization is* known and the IMPORTS edges exist). */static void k8s_bundles_build(cbm_pipeline_ctx_t *ctx, k8s_kusts_t *ks, k8s_bundles_t *b) {@@ -1285,6 +1291,9 @@ typedef struct {int64_t node;char *image;char *container; /* NULL: unnamed */+ int line; /* the image's line */+ int start_line; /* the container's lines */+ int end_line;} k8s_img_t;/* A patch a kustomization states (extract_k8s.c PATCH fact): what it names@@ -1482,8 +1491,12 @@ static void k8s_facts_keep(k8s_facts_t *f, const CBMFileResult *res, const int64} else if (x->fact == CBM_K8S_FACT_IMAGE) {if (x->name && k8s_grow((void **)&f->imgs, &f->img_cap, f->img_n, sizeof(*f->imgs))) {f->imgs[f->img_n++] = (k8s_img_t){- node, cbm_mem_strdup(CBM_MEM_CLASS_OTHER, x->name),- x->container ? cbm_mem_strdup(CBM_MEM_CLASS_OTHER, x->container) : NULL};+ node,+ cbm_mem_strdup(CBM_MEM_CLASS_OTHER, x->name),+ x->container ? cbm_mem_strdup(CBM_MEM_CLASS_OTHER, x->container) : NULL,+ x->line,+ x->start_line,+ x->end_line};}} else if (x->fact == CBM_K8S_FACT_ENV) {if (x->name && k8s_grow((void **)&f->envs, &f->env_cap, f->env_n, sizeof(*f->envs))) {@@ -2772,6 +2785,27 @@ static void k8s_link_local_deps(cbm_pipeline_ctx_t *ctx, k8s_local_deps_t *deps)* `file://` dependency (once all charts are read), otherwise to the external* Chart node of the dependency's repository and name, the repository also on* the edge. */+/* The Chart node `name` defined by chart file `rel_path` (a Chart.yaml, a+ * werf.yaml), its File node DEFINES it; 0 on failure. */+static int64_t k8s_chart_upsert(cbm_pipeline_ctx_t *ctx, const char *rel_path, const char *name,+ const char *props) {+ char *chart_qn = cbm_infra_qn(ctx->project_name, rel_path, "helm-chart", NULL);+ if (!chart_qn) {+ return 0;+ }+ int64_t chart_id =+ cbm_gbuf_upsert_node(ctx->gbuf, "Chart", name, chart_qn, rel_path, SKIP_ONE, 0, props);+ free(chart_qn);++ char *file_qn = cbm_pipeline_fqn_compute(ctx->project_name, rel_path, "__file__");+ const cbm_gbuf_node_t *file_node = file_qn ? cbm_gbuf_find_by_qn(ctx->gbuf, file_qn) : NULL;+ if (file_node && chart_id > 0) {+ cbm_gbuf_insert_edge(ctx->gbuf, file_node->id, chart_id, "DEFINES", "{}");+ }+ free(file_qn);+ return chart_id > 0 ? chart_id : 0;+}+static void handle_helm_chart(cbm_pipeline_ctx_t *ctx, const char *rel_path, const char *source,k8s_local_deps_t *local_deps) {cbm_helm_chart_t hc;@@ -2781,24 +2815,14 @@ static void handle_helm_chart(cbm_pipeline_ctx_t *ctx, const char *rel_path, con}const char *cname = hc.chart_name[0] ? hc.chart_name : k8s_basename(rel_path);- char *chart_qn = cbm_infra_qn(ctx->project_name, rel_path, "helm-chart", NULL);- if (!chart_qn) {+ int64_t chart_id = k8s_chart_upsert(ctx, rel_path, cname, "{\"source\":\"helm\"}");+ if (chart_id <= 0) {cbm_helm_chart_free(&hc);return;}- int64_t chart_id = cbm_gbuf_upsert_node(ctx->gbuf, "Chart", cname, chart_qn, rel_path, SKIP_ONE,- 0, "{\"source\":\"helm\"}");- free(chart_qn);-- char *file_qn = cbm_pipeline_fqn_compute(ctx->project_name, rel_path, "__file__");- const cbm_gbuf_node_t *file_node = file_qn ? cbm_gbuf_find_by_qn(ctx->gbuf, file_qn) : NULL;- if (file_node && chart_id > 0) {- cbm_gbuf_insert_edge(ctx->gbuf, file_node->id, chart_id, "DEFINES", "{}");- }- free(file_qn);int dep_edges = 0;- for (int i = 0; i < hc.dep_count && chart_id > 0; i++) {+ for (int i = 0; i < hc.dep_count; i++) {const cbm_helm_dep_t *dep = &hc.deps[i];if (k8s_is_file_repository(dep->repository)) {k8s_local_deps_push(local_deps, chart_id, rel_path, ctx->project_name, dep);@@ -2812,6 +2836,106 @@ static void handle_helm_chart(cbm_pipeline_ctx_t *ctx, const char *rel_path, concbm_log_info("pass.k8s.helm", "file", rel_path, "deps", itoa_k8s(dep_edges));}+/* ── werf chart handler ──────────────────────────────────────────── */++/* werf (werf.io) deploys the Helm chart in the `.helm` directory beside its+ * werf.yaml; that chart needs no Chart.yaml, werf names it after its project.+ * A `.helm` with a Chart.yaml is an ordinary chart. A custom+ * deploy.helmChartDir is not followed. */+static bool is_werf_file(const char *base) {+ return strcmp(base, "werf.yaml") == 0 || strcmp(base, "werf.yml") == 0;+}++bool cbm_werf_helm_dir(const char *repo_path, const char *dir) {+ const char *base = k8s_basename(dir);+ if (!repo_path || strcmp(base, ".helm") != 0) {+ return false;+ }+ char path[CBM_SZ_4K];+ snprintf(path, sizeof(path), "%s/%s", repo_path, dir);+ if (!cbm_is_dir(path)) {+ return false;+ }+ static const char *const charts[] = {"Chart.yaml", "Chart.yml"};+ for (size_t i = 0; i < sizeof(charts) / sizeof(charts[0]); i++) {+ snprintf(path, sizeof(path), "%s/%s/%s", repo_path, dir, charts[i]);+ if (cbm_file_exists(path)) {+ return false;+ }+ }+ size_t parent = (size_t)(base - dir);+ static const char *const werfs[] = {"werf.yaml", "werf.yml"};+ for (size_t i = 0; i < sizeof(werfs) / sizeof(werfs[0]); i++) {+ snprintf(path, sizeof(path), "%s/%.*s%s", repo_path, (int)parent, dir, werfs[i]);+ if (cbm_file_exists(path)) {+ return true;+ }+ }+ return false;+}++/* The literal top-level `project:` of a werf.yaml's first document into out,+ * "" when there is none or it is templated. */+static void k8s_werf_project(const char *src, char *out, size_t out_sz) {+ out[0] = '\0';+ bool seen_key = false;+ for (const char *p = src; p && *p;) {+ const char *eol = strchr(p, '\n');+ size_t len = eol ? (size_t)(eol - p) : strlen(p);+ if (len >= K8S_SLEN("---") && strncmp(p, "---", K8S_SLEN("---")) == 0 && seen_key) {+ return;+ }+ if (isalpha((unsigned char)p[0])) {+ seen_key = true;+ }+ if (len > K8S_SLEN("project:") && strncmp(p, "project:", K8S_SLEN("project:")) == 0) {+ /* the value: [b, e) of the line, a comment and quotes removed */+ size_t b = K8S_SLEN("project:");+ size_t e = len;+ while (b < e && (p[b] == ' ' || p[b] == '\t')) {+ b++;+ }+ for (size_t i = b; i < e; i++) {+ if (p[i] == '#') {+ e = i;+ }+ }+ while (e > b && isspace((unsigned char)p[e - SKIP_ONE])) {+ e--;+ }+ if (e >= b + PAIR_LEN && (p[b] == '"' || p[b] == '\'') && p[e - SKIP_ONE] == p[b]) {+ b++;+ e--;+ }+ if (e > b && e - b < out_sz && !memchr(p + b, '{', e - b)) {+ memcpy(out, p + b, e - b);+ out[e - b] = '\0';+ }+ return;+ }+ p = eol ? eol + SKIP_ONE : NULL;+ }+}++/* A werf.yaml beside a `.helm` chart dir: a Chart named after its project+ * {source: werf}, defined by werf.yaml, and the chart dir into `chart_dir`.+ * False when it has no such chart. */+static bool handle_werf_chart(cbm_pipeline_ctx_t *ctx, const char *rel_path, const char *source,+ char *chart_dir, size_t chart_dir_sz) {+ char dir[CBM_SZ_1K];+ k8s_dirname(rel_path, dir, sizeof(dir));+ snprintf(chart_dir, chart_dir_sz, "%s%s.helm", dir, dir[0] ? "/" : "");+ if (!cbm_werf_helm_dir(ctx->repo_path, chart_dir)) {+ return false;+ }+ char project[CBM_HELM_NAME_MAX];+ k8s_werf_project(source, project, sizeof(project));+ const char *cname = project[0] ? project : k8s_basename(rel_path);+ int64_t chart_id = k8s_chart_upsert(ctx, rel_path, cname, "{\"source\":\"werf\"}");+ cbm_log_info("pass.k8s.werf", "file", rel_path, "chart", cname);+ return chart_id > 0;+}+/* ── Dependency-manifest handler (go.mod / requirements.txt) ──────── */static bool is_gomod_file(const char *base) {@@ -2969,7 +3093,7 @@ static void handle_dep_manifest(cbm_pipeline_ctx_t *ctx, const char *rel_path, c* the sequential loop did. Sequentially the pass re-read and re-parsed every* YAML manifest on one thread -- 1.1 s of the Go corpus (6,275 manifests;* profile + waste sanitizer, 2026-09-17). */-typedef enum { K8S_SKIP = 0, K8S_DEP, K8S_HELM, K8S_MANIFEST, K8S_KUSTOMIZE } k8s_kind_t;+typedef enum { K8S_SKIP = 0, K8S_DEP, K8S_HELM, K8S_WERF, K8S_MANIFEST, K8S_KUSTOMIZE } k8s_kind_t;typedef struct {k8s_kind_t kind;@@ -3153,6 +3277,8 @@ static void k8s_prep_file(const k8s_prep_job_t *job, int i, k8s_prep_t *out) {}if (is_helm_chart_file(base)) {out->kind = K8S_HELM;+ } else if (is_werf_file(base)) {+ out->kind = K8S_WERF;} else if (cbm_is_k8s_manifest(base, out->source)) {/* Always re-extract with CBM_LANG_K8S regardless of any cached* result: cached results were produced during the parallel YAML@@ -3610,7 +3736,8 @@ static void k8s_deploys_edge(k8s_dep_link_t *l, int64_t src, int64_t tgt, const}}-/* The Chart node of chart dir `dir`, 0 when it is none. */+/* The Chart node of chart dir `dir`, 0 when it is none: its Chart.yaml's, or+ * for a werf `.helm` dir the one its werf.yaml defines. */static int64_t k8s_chart_node(k8s_dep_link_t *l, const char *dir) {static const char *const names[] = {"Chart.yaml", "Chart.yml"};for (size_t i = 0; i < sizeof(names) / sizeof(names[0]); i++) {@@ -3621,6 +3748,19 @@ static int64_t k8s_chart_node(k8s_dep_link_t *l, const char *dir) {return id;}}+ const char *base = k8s_basename(dir);+ if (strcmp(base, ".helm") != 0) {+ return 0;+ }+ static const char *const werfs[] = {"werf.yaml", "werf.yml"};+ for (size_t i = 0; i < sizeof(werfs) / sizeof(werfs[0]); i++) {+ char path[CBM_SZ_1K];+ snprintf(path, sizeof(path), "%.*s%s", (int)(base - dir), dir, werfs[i]);+ int64_t id = k8s_first_id(l->charts, path);+ if (id > 0) {+ return id;+ }+ }return 0;}@@ -3661,8 +3801,10 @@ static bool k8s_chart_values_file(const char *rel, const char *dir) {/* A chart deploys what its templates render: Chart -DEPLOYS {via: chart}->* each Resource of <chart>/templates/ -- its nearest enclosing chart, so a- * subchart's objects are the subchart's. Its values files (values.yaml,- * values-<x>.yaml beside Chart.yaml) CONFIGURE {strategy: helm_values} it. */+ * subchart's objects are the subchart's -- and each CRD of <chart>/crds/,+ * which Helm installs first ({via: chart, phase: crds}). Its values files+ * (values.yaml, values-<x>.yaml beside Chart.yaml) CONFIGURE {strategy:+ * helm_values} it. */static void k8s_link_chart_contents(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b) {if (!b->charts || cbm_ht_count(b->charts) == 0) {return;@@ -3691,9 +3833,14 @@ static void k8s_link_chart_contents(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b) {}if (k == 0) {char tpl[CBM_SZ_1K];+ char crd[CBM_SZ_1K];snprintf(tpl, sizeof(tpl), "%s%stemplates/", dir, dir[0] ? "/" : "");+ snprintf(crd, sizeof(crd), "%s%scrds/", dir, dir[0] ? "/" : "");if (strncmp(fp, tpl, strlen(tpl)) == 0) {k8s_deploys_edge(&l, chart, nodes[i]->id, "{\"via\":\"chart\"}");+ } else if (strncmp(fp, crd, strlen(crd)) == 0) {+ k8s_deploys_edge(&l, chart, nodes[i]->id,+ "{\"via\":\"chart\",\"phase\":\"crds\"}");}} else if (k8s_chart_values_file(fp, dir)) {cbm_gbuf_insert_edge(ctx->gbuf, nodes[i]->id, chart, "CONFIGURES",@@ -3709,19 +3856,1039 @@ static void k8s_link_chart_contents(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b) {}}-/* Each Image a chart's objects name literally (their USAGE {ref: image}, after+/* ── Helm template images (PHASE 2 P2.5) ─────────────────────────────+ *+ * A chart template's container image is a placeholder in the skeleton+ * (`<.Values.image.repository>`): it is rendered here (helm_template.c) from+ * the chart's own values.yaml, its Chart.yaml (.Chart) and the defines of its+ * chart family -- what `helm template` writes with the chart's defaults. The+ * object then USES the Image {ref: image, default_of: the values keys read},+ * an image nothing else in the repository changes but a release can. A+ * parent chart that changes it for its subchart (its `<sub>:` values, its+ * `global:`) DEPLOYS the Image it makes {via: chart, ref: image,+ * override_of}. A value that does not render (helm_template.h: UNKNOWN) or+ * is no image reference names none. */++typedef struct {+ int64_t node;+ char *file;+ char *container; /* NULL: unnamed */+ int start_line;+ int end_line;+} k8s_timg_t;++typedef struct {+ char *dir;+ int64_t chart;+ cbm_helm_chart_meta_t meta;+ yyjson_mut_val *chart_yaml; /* NULL: none */+ yyjson_mut_val *values; /* NULL: values.yaml does not parse (nothing renders) */+} k8s_hchart_t;++/* A template file of a chart family (its defines). */+typedef struct {+ char *file;+ char *family;+} k8s_htpl_t;++/* One rendered image of an object (or a chart / release). */+typedef struct {+ int64_t src;+ int64_t img;+ const char *ref;+ const char *container;+ const char *keys; /* JSON array; NULL: none */+} k8s_himg_t;++typedef struct {+ k8s_himg_t *v;+ int n;+ int cap;+} k8s_himgs_t;++typedef struct {+ yyjson_mut_doc *doc;+ CBMArena a;+ CBMHashTable *charts; /* chart dir -> k8s_hchart_t* */+ CBMHashTable *defines; /* family dir -> cbm_helm_defines_t* */+ k8s_htpl_t *tpls;+ int ntpl;+ bool tpls_read;+ k8s_timg_t *t;+ int nt;+ int tcap;+ k8s_himgs_t dflt; /* the containers' images with the defaults */+ int edges;+} k8s_helm_t;++/* The templated images of the facts, kept past them. */+static void k8s_helm_collect(cbm_pipeline_ctx_t *ctx, const k8s_facts_t *f, k8s_helm_t *h) {+ for (int i = 0; i < f->img_n; i++) {+ const k8s_img_t *im = &f->imgs[i];+ const cbm_gbuf_node_t *n =+ strchr(im->image, '<') ? cbm_gbuf_find_by_id(ctx->gbuf, im->node) : NULL;+ if (!n || !n->file_path || im->start_line <= 0) {+ continue;+ }+ if (!k8s_grow((void **)&h->t, &h->tcap, h->nt, sizeof(*h->t))) {+ return;+ }+ h->t[h->nt++] = (k8s_timg_t){im->node, cbm_arena_strdup(&h->a, n->file_path),+ im->container ? cbm_arena_strdup(&h->a, im->container) : NULL,+ im->start_line, im->end_line};+ }+}++static char *k8s_repo_read(cbm_pipeline_ctx_t *ctx, const char *rel, int *len) {+ char path[CBM_SZ_4K];+ snprintf(path, sizeof(path), "%s/%s", ctx->repo_path, rel);+ return k8s_read_file(path, len);+}++/* A file of `dir` (one of `names`), parsed as values; *found when one exists. */+static yyjson_mut_val *k8s_helm_yaml(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, const char *dir,+ const char *const *names, bool *found) {+ *found = false;+ for (int i = 0; names[i]; i++) {+ char rel[CBM_SZ_1K];+ snprintf(rel, sizeof(rel), "%s%s%s", dir, dir[0] ? "/" : "", names[i]);+ int len = 0;+ char *src = k8s_repo_read(ctx, rel, &len);+ if (!src) {+ continue;+ }+ *found = true;+ yyjson_mut_val *v = cbm_helm_values_parse(h->doc, src, (size_t)len);+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ return v;+ }+ return NULL;+}++static const char *k8s_helm_meta_str(yyjson_mut_val *obj, const char *key) {+ yyjson_mut_val *v = yyjson_mut_is_obj(obj) ? yyjson_mut_obj_get(obj, key) : NULL;+ return yyjson_mut_is_str(v) ? yyjson_mut_get_str(v) : NULL;+}++/* The chart of chart dir `dir` with its metadata and default values. */+static k8s_hchart_t *k8s_helm_chart(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, k8s_dep_link_t *l,+ const char *dir) {+ k8s_hchart_t *c = cbm_ht_get(h->charts, dir);+ if (c) {+ return c;+ }+ c = cbm_arena_calloc(&h->a, sizeof(*c));+ if (!c) {+ return NULL;+ }+ c->dir = cbm_arena_strdup(&h->a, dir);+ c->chart = k8s_chart_node(l, dir);+ static const char *const CHART[] = {"Chart.yaml", "Chart.yml", NULL};+ static const char *const VALUES[] = {"values.yaml", "values.yml", NULL};+ bool found = false;+ c->chart_yaml = k8s_helm_yaml(ctx, h, dir, CHART, &found);+ yyjson_mut_val *vals = k8s_helm_yaml(ctx, h, dir, VALUES, &found);+ c->values = found ? vals : yyjson_mut_obj(h->doc);+ const cbm_gbuf_node_t *cn = c->chart > 0 ? cbm_gbuf_find_by_id(ctx->gbuf, c->chart) : NULL;+ const char *name = k8s_helm_meta_str(c->chart_yaml, "name");+ c->meta.name = name ? name : cn && cn->name ? cbm_arena_strdup(&h->a, cn->name) : NULL;+ c->meta.version = k8s_helm_meta_str(c->chart_yaml, "version");+ c->meta.app_version = k8s_helm_meta_str(c->chart_yaml, "appVersion");+ cbm_ht_set(h->charts, c->dir, c);+ return c;+}++static bool k8s_helm_tpl_ext(const char *p) {+ static const char *const EXT[] = {".yaml", ".yml", ".tpl", ".gotmpl", ".txt", ".json"};+ for (size_t i = 0; i < sizeof(EXT) / sizeof(EXT[0]); i++) {+ if (k8s_has_suffix(p, EXT[i])) {+ return true;+ }+ }+ return false;+}++/* The defines of chart family `family`: every template (<chart>/templates/)+ * of its charts, read from disk. */+static const cbm_helm_defines_t *k8s_helm_defines(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b,+ k8s_helm_t *h, const char *family) {+ cbm_helm_defines_t *d = cbm_ht_get(h->defines, family);+ if (d) {+ return d;+ }+ if (!h->tpls_read) {+ h->tpls_read = true;+ const cbm_gbuf_node_t **files = NULL;+ int n = 0;+ if (cbm_gbuf_find_by_label(ctx->gbuf, "File", &files, &n) == 0 && n > 0) {+ h->tpls = cbm_arena_alloc(&h->a, (size_t)n * sizeof(*h->tpls));+ for (int i = 0; h->tpls && i < n; i++) {+ const char *fp = files[i]->file_path;+ char dir[CBM_SZ_1K];+ char fam[CBM_SZ_1K];+ char tdir[CBM_SZ_1K];+ if (!fp || !k8s_helm_tpl_ext(fp) || !k8s_chart_of(b, fp, dir, sizeof(dir))) {+ continue;+ }+ snprintf(tdir, sizeof(tdir), "%s%stemplates/", dir, dir[0] ? "/" : "");+ if (strncmp(fp, tdir, strlen(tdir)) != 0) {+ continue;+ }+ k8s_chart_family(b, dir, fam, sizeof(fam));+ h->tpls[h->ntpl++] =+ (k8s_htpl_t){cbm_arena_strdup(&h->a, fp), cbm_arena_strdup(&h->a, fam)};+ }+ }+ }+ d = cbm_helm_defines_new();+ if (!d) {+ return NULL;+ }+ for (int i = 0; i < h->ntpl; i++) {+ if (strcmp(h->tpls[i].family, family) != 0) {+ continue;+ }+ int len = 0;+ char *src = k8s_repo_read(ctx, h->tpls[i].file, &len);+ if (src) {+ cbm_helm_defines_add(d, h->tpls[i].file, src, (size_t)len);+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ }+ }+ cbm_ht_set(h->defines, cbm_arena_strdup(&h->a, family), d);+ return d;+}++static void k8s_helm_free_defines(const char *key, void *value, void *ud) {+ (void)key;+ (void)ud;+ cbm_helm_defines_free(value);+}++static int k8s_timg_cmp(const void *x, const void *y) {+ const k8s_timg_t *a = x;+ const k8s_timg_t *b = y;+ int c = strcmp(a->file, b->file);+ return c ? c : a->start_line - b->start_line;+}++/* Does template line `line` (1-based) of src hold an `image:` key? */+static bool k8s_helm_image_line(const char *src, size_t len, const uint32_t *starts, int line) {+ size_t k = starts[line - SKIP_ONE];+ while (k < len && (src[k] == ' ' || src[k] == '\t')) {+ k++;+ }+ if (k + SKIP_ONE < len && src[k] == '-' && src[k + SKIP_ONE] == ' ') {+ k++;+ while (k < len && src[k] == ' ') {+ k++;+ }+ }+ return k + strlen("image:") <= len && memcmp(src + k, "image:", strlen("image:")) == 0;+}++/* The probes of a template's templated images [from, to): each `image:`+ * line inside a container (both branches of an if / else among them). */+static int k8s_helm_probes(k8s_helm_t *h, const k8s_timg_t *t, int from, int to, const char *src,+ size_t len, cbm_helm_probe_t **out) {+ int nl = SKIP_ONE;+ for (size_t i = 0; i < len; i++) {+ nl += src[i] == '\n';+ }+ uint32_t *starts = cbm_arena_alloc(&h->a, (size_t)nl * sizeof(*starts));+ if (!starts) {+ return 0;+ }+ int k = 0;+ starts[k++] = 0;+ for (size_t i = 0; i < len && k < nl; i++) {+ if (src[i] == '\n') {+ starts[k++] = (uint32_t)(i + SKIP_ONE);+ }+ }+ int cap = 0;+ for (int i = from; i < to; i++) {+ cap += t[i].end_line - t[i].start_line + SKIP_ONE;+ }+ cbm_helm_probe_t *p = cap ? cbm_arena_calloc(&h->a, (size_t)cap * sizeof(*p)) : NULL;+ int np = 0;+ for (int i = from; p && i < to; i++) {+ for (int line = t[i].start_line; line <= t[i].end_line && line <= k; line++) {+ bool dup = false;+ for (int j = 0; j < np && !dup; j++) {+ dup = p[j].line == line;+ }+ if (!dup && k8s_helm_image_line(src, len, starts, line)) {+ p[np++].line = line;+ }+ }+ }+ *out = p;+ return np;+}++static yyjson_mut_val *k8s_helm_dig(yyjson_mut_val *v, const char *path) {+ const char *p = path;+ while (v && *p) {+ const char *dot = strchr(p, '.');+ size_t kl = dot ? (size_t)(dot - p) : strlen(p);+ v = yyjson_mut_is_obj(v) ? yyjson_mut_obj_getn(v, p, kl) : NULL;+ p += kl + (dot ? SKIP_ONE : 0);+ }+ return v;+}++/* Is values key path `key` (dot-joined, `\.` escaped) set in `v`? */+static bool k8s_helm_sets(yyjson_mut_val *v, const char *key) {+ char part[CBM_SZ_512];+ const char *p = key;+ while (v && *p) {+ size_t k = 0;+ while (*p && *p != '.' && *p != '[' && k + SKIP_ONE < sizeof(part)) {+ if (*p == '\\' && p[1]) {+ p++;+ }+ part[k++] = *p++;+ }+ part[k] = '\0';+ v = yyjson_mut_is_obj(v) ? yyjson_mut_obj_get(v, part) : NULL;+ while (v && *p == '[') {+ long idx = strtol(p + SKIP_ONE, (char **)&p, 10);+ p += *p == ']' ? SKIP_ONE : 0;+ v = yyjson_mut_is_arr(v) ? yyjson_mut_arr_get(v, (size_t)idx) : NULL;+ }+ if (*p == '.') {+ p++;+ }+ }+ return v != NULL;+}++/* The values keys of JSON array `keys` that `overlay` sets (relative to+ * the chart), prefixed by `prefix` -- as a JSON array; NULL: none. */+static const char *k8s_helm_overridden(k8s_helm_t *h, const char *keys, yyjson_mut_val *overlay,+ yyjson_mut_val *globals, const char *prefix) {+ if (!keys) {+ return NULL;+ }+ yyjson_doc *doc = yyjson_read(keys, strlen(keys), 0);+ yyjson_val *arr = doc ? yyjson_doc_get_root(doc) : NULL;+ const char *out = NULL;+ if (yyjson_is_arr(arr)) {+ size_t idx, max;+ yyjson_val *k;+ yyjson_arr_foreach(arr, idx, max, k) {+ const char *key = yyjson_get_str(k);+ bool global = key && strncmp(key, "global.", strlen("global.")) == 0;+ bool set = key && (global ? k8s_helm_sets(globals, key + strlen("global."))+ : k8s_helm_sets(overlay, key));+ if (!set) {+ continue;+ }+ char esc[CBM_SZ_1K];+ cbm_json_escape(esc, (int)sizeof(esc), key);+ out = cbm_arena_sprintf(&h->a, "%s%s\"%s%s%s\"", out ? out : "[", out ? "," : "",+ global || !prefix ? "" : prefix, global || !prefix ? "" : ".",+ esc);+ }+ }+ if (doc) {+ yyjson_doc_free(doc);+ }+ return out ? cbm_arena_sprintf(&h->a, "%s]", out) : NULL;+}++static void k8s_himg_push(k8s_himgs_t *l, k8s_himg_t x) {+ for (int i = 0; i < l->n; i++) {+ if (l->v[i].src == x.src && l->v[i].img == x.img) {+ return; /* the first (in file order) of the same Image stands for it */+ }+ }+ if (k8s_grow((void **)&l->v, &l->cap, l->n, sizeof(*l->v))) {+ l->v[l->n++] = x;+ }+}++/* Does `src` USE Image `img` already by a literal reference? */+static bool k8s_helm_literal_use(cbm_pipeline_ctx_t *ctx, int64_t src, int64_t img) {+ const cbm_gbuf_edge_t **es = NULL;+ int n = 0;+ if (cbm_gbuf_find_edges_by_source_type(ctx->gbuf, src, "USAGE", &es, &n) != 0) {+ return false;+ }+ for (int i = 0; i < n; i++) {+ if (es[i]->target_id == img && es[i]->properties_json &&+ strstr(es[i]->properties_json, "\"ref\":\"image\"")) {+ return true;+ }+ }+ return false;+}++/* The captures of probes within [first, last] lines, as images of `src`. */+static void k8s_helm_take(cbm_pipeline_ctx_t *ctx, const cbm_helm_probe_t *p, int np, int first,+ int last, int64_t src, const char *container, k8s_himgs_t *out) {+ for (int i = 0; i < np; i++) {+ if (p[i].line < first || p[i].line > last) {+ continue;+ }+ for (int c = 0; c < p[i].n; c++) {+ const char *ref = p[i].image[c];+ int64_t img = ref && cbm_image_ref_valid(ref) ? cbm_pipeline_image_node(ctx, ref) : 0;+ if (img > 0) {+ k8s_himg_push(out, (k8s_himg_t){src, img, ref, container, p[i].keys[c]});+ }+ }+ }+}++/* The images of templated containers [from, to) of one template, rendered+ * with `values` (NULL: the chart's own). */+static void k8s_helm_render(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, k8s_bundles_t *b,+ const k8s_hchart_t *c, const k8s_timg_t *t, int from, int to,+ yyjson_mut_val *values, const char *src, size_t len,+ cbm_helm_probe_t *probes, int np) {+ char fam[CBM_SZ_1K];+ k8s_chart_family(b, c->dir, fam, sizeof(fam));+ const cbm_helm_defines_t *defs = k8s_helm_defines(ctx, b, h, fam);+ cbm_helm_render(&h->a, t[from].file, src, len, values ? values : c->values, &c->meta, defs,+ probes, np);+ (void)to;+}++static void k8s_helm_emit_uses(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, const k8s_himgs_t *l) {+ for (int i = 0; i < l->n; i++) {+ const k8s_himg_t *x = &l->v[i];+ if (k8s_helm_literal_use(ctx, x->src, x->img)) {+ continue; /* a literal reference of the object wins */+ }+ char esc[CBM_SZ_1K];+ char cesc[CBM_SZ_512];+ cbm_json_escape(esc, (int)sizeof(esc), x->ref);+ cbm_json_escape(cesc, (int)sizeof(cesc), x->container ? x->container : "-");+ const char *props = cbm_arena_sprintf(+ &h->a, "{\"ref\":\"image\",\"image\":\"%s\",\"container\":\"%s\"%s%s}", esc, cesc,+ x->keys ? ",\"default_of\":" : "", x->keys ? x->keys : "");+ if (props) {+ cbm_gbuf_insert_edge(ctx->gbuf, x->src, x->img, "USAGE", props);+ h->edges++;+ }+ }+}++/* Chart `from` -DEPLOYS {via, ref: image, image, override_of}-> the images an+ * overlay changed: rendered there, absent from the defaults' images. */+static void k8s_helm_emit_overrides(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, int64_t from,+ const char *via, const k8s_himgs_t *dflt,+ const k8s_himgs_t *got, yyjson_mut_val *overlay,+ yyjson_mut_val *globals, const char *prefix,+ k8s_himgs_t *emitted) {+ for (int i = 0; i < got->n; i++) {+ const k8s_himg_t *x = &got->v[i];+ bool same = false;+ for (int j = 0; j < dflt->n && !same; j++) {+ same = dflt->v[j].src == x->src && dflt->v[j].img == x->img &&+ strcmp(dflt->v[j].ref, x->ref) == 0;+ }+ const char *ovr = k8s_helm_overridden(h, x->keys, overlay, globals, prefix);+ if (same || !ovr || from <= 0) {+ continue;+ }+ k8s_himg_t e = {from, x->img, x->ref, NULL, ovr};+ int before = emitted->n;+ k8s_himg_push(emitted, e);+ if (emitted->n == before) {+ continue;+ }+ char esc[CBM_SZ_1K];+ cbm_json_escape(esc, (int)sizeof(esc), x->ref);+ const char *props = cbm_arena_sprintf(+ &h->a, "{\"via\":\"%s\",\"ref\":\"image\",\"image\":\"%s\",\"override_of\":%s}", via,+ esc, ovr);+ if (props) {+ cbm_gbuf_insert_edge(ctx->gbuf, from, x->img, "DEPLOYS", props);+ h->edges++;+ }+ }+}++/* The chart dirs enclosing chart dir `dir`, nearest first (arena). */+static int k8s_helm_ancestors(k8s_helm_t *h, k8s_bundles_t *b, const char *dir, const char ***out) {+ int n = 0;+ int cap = 0;+ const char **v = NULL;+ char cur[CBM_SZ_1K];+ snprintf(cur, sizeof(cur), "%s", dir);+ while (cur[0]) {+ char up[CBM_SZ_1K];+ if (!k8s_chart_of(b, cur, up, sizeof(up))) {+ break;+ }+ if (n == cap) {+ cap = cap ? cap * PAIR_LEN : CBM_SZ_16;+ const char **g = cbm_arena_alloc(&h->a, (size_t)cap * sizeof(*g));+ if (!g) {+ break;+ }+ if (n) {+ memcpy(g, v, (size_t)n * sizeof(*g));+ }+ v = g;+ }+ v[n++] = cbm_arena_strdup(&h->a, up);+ snprintf(cur, sizeof(cur), "%s", up);+ }+ *out = v;+ return n;+}++/* The dependency of `parent`'s Chart.yaml naming `sub` (by name), NULL: none. */+static yyjson_mut_val *k8s_helm_dep(const k8s_hchart_t *parent, const k8s_hchart_t *sub) {+ yyjson_mut_val *deps = yyjson_mut_is_obj(parent->chart_yaml)+ ? yyjson_mut_obj_get(parent->chart_yaml, "dependencies")+ : NULL;+ if (yyjson_mut_is_arr(deps) && sub->meta.name) {+ size_t idx, max;+ yyjson_mut_val *d;+ yyjson_mut_arr_foreach(deps, idx, max, d) {+ const char *name = k8s_helm_meta_str(d, "name");+ if (name && strcmp(name, sub->meta.name) == 0) {+ return d;+ }+ }+ }+ return NULL;+}++/* Is the subchart a dependency disables in the parent's values `vals` (its+ * `condition`: the first of its comma-separated paths that holds a bool)? */+static bool k8s_helm_disabled(k8s_helm_t *h, yyjson_mut_val *dep, yyjson_mut_val *vals) {+ const char *cond = dep ? k8s_helm_meta_str(dep, "condition") : NULL;+ for (const char *p = cond; p && *p;) {+ const char *comma = strchr(p, ',');+ size_t l = comma ? (size_t)(comma - p) : strlen(p);+ char *path = cbm_arena_strndup(&h->a, p, l);+ yyjson_mut_val *v = path ? k8s_helm_dig(vals, path) : NULL;+ if (yyjson_mut_is_bool(v)) {+ return !yyjson_mut_get_bool(v);+ }+ p += l + (comma ? SKIP_ONE : 0);+ }+ return false;+}++/* The values chart dir `dir` renders with when chart dir `top` deploys it+ * with values `top_vals` (NULL: top's defaults): down the charts between+ * them, each subchart's defaults with its parent's `<alias>:` values and+ * `global:` coalesced over them (Helm's coalesce; a subchart always has a+ * `global`). *path gets dir's key path from top ("" for top itself). NULL:+ * a dependency condition disables it, or a values file does not parse. */+static yyjson_mut_val *k8s_helm_context(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, k8s_bundles_t *b,+ k8s_dep_link_t *l, const char *dir, const char *top,+ yyjson_mut_val *top_vals, const char **path) {+ const char **anc = NULL;+ int na = k8s_helm_ancestors(h, b, dir, &anc);+ int ti = -SKIP_ONE; /* top's index among the ancestors; na: dir itself */+ if (strcmp(dir, top) == 0) {+ ti = na;+ } else {+ for (int i = 0; i < na && ti < 0; i++) {+ ti = strcmp(anc[i], top) == 0 ? i : ti;+ }+ }+ *path = "";+ if (ti < 0) {+ return NULL;+ }+ k8s_hchart_t *cur_chart = k8s_helm_chart(ctx, h, l, top);+ if (!cur_chart || !cur_chart->values) {+ return NULL;+ }+ yyjson_mut_val *cur = top_vals ? cbm_helm_values_coalesce(h->doc, cur_chart->values, top_vals)+ : cur_chart->values;+ for (int i = (ti == na ? na : ti) - SKIP_ONE; i >= -SKIP_ONE && ti != na; i--) {+ k8s_hchart_t *child = k8s_helm_chart(ctx, h, l, i >= 0 ? anc[i] : dir);+ if (!child || !child->values) {+ return NULL;+ }+ yyjson_mut_val *dep = k8s_helm_dep(cur_chart, child);+ if (k8s_helm_disabled(h, dep, cur)) {+ return NULL;+ }+ const char *alias = dep ? k8s_helm_meta_str(dep, "alias") : NULL;+ alias = alias ? alias : child->meta.name;+ if (!alias) {+ return NULL;+ }+ *path = (*path)[0] ? cbm_arena_sprintf(&h->a, "%s.%s", *path, alias)+ : cbm_arena_strdup(&h->a, alias);+ yyjson_mut_val *sub = yyjson_mut_is_obj(cur) ? yyjson_mut_obj_get(cur, alias) : NULL;+ yyjson_mut_val *next = cbm_helm_values_coalesce(h->doc, child->values, sub);+ yyjson_mut_val *pg = yyjson_mut_is_obj(cur) ? yyjson_mut_obj_get(cur, "global") : NULL;+ yyjson_mut_val *cg = next ? yyjson_mut_obj_get(next, "global") : NULL;+ yyjson_mut_val *g = cbm_helm_values_coalesce(h->doc, cg, pg); /* the parent's win */+ if (!next || !g) {+ return NULL;+ }+ (void)yyjson_mut_obj_remove_key(next, "global");+ yyjson_mut_obj_add(next, yyjson_mut_strcpy(h->doc, "global"), g);+ cur = next;+ cur_chart = child;+ }+ return cur;+}++/* Render the templated containers [from, to) of one template with `vals`+ * and take each container's images. */+static void k8s_helm_images_of(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, k8s_bundles_t *b,+ const k8s_hchart_t *c, int from, int to, yyjson_mut_val *vals,+ const char *src, size_t len, cbm_helm_probe_t *probes, int np,+ k8s_himgs_t *out) {+ k8s_helm_render(ctx, h, b, c, h->t, from, to, vals, src, len, probes, np);+ for (int i = from; i < to; i++) {+ k8s_helm_take(ctx, probes, np, h->t[i].start_line, h->t[i].end_line, h->t[i].node,+ h->t[i].container, out);+ }+}++/* Every templated container's images with its chart family's defaults --+ * what `helm template <family root>` renders. */+static void k8s_helm_link_defaults(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b, k8s_helm_t *h) {+ if (h->nt == 0 || !ctx->repo_path) {+ return;+ }+ qsort(h->t, (size_t)h->nt, sizeof(*h->t), k8s_timg_cmp);+ k8s_dep_link_t l = {.ctx = ctx, .charts = k8s_index_by_file(ctx, "Chart")};+ k8s_himgs_t uses = {0};+ for (int from = 0; from < h->nt;) {+ int to = from + SKIP_ONE;+ while (to < h->nt && strcmp(h->t[to].file, h->t[from].file) == 0) {+ to++;+ }+ char dir[CBM_SZ_1K];+ char fam[CBM_SZ_1K];+ k8s_hchart_t *c = k8s_chart_of(b, h->t[from].file, dir, sizeof(dir))+ ? k8s_helm_chart(ctx, h, &l, dir)+ : NULL;+ const char *path = NULL;+ yyjson_mut_val *vals = NULL;+ if (c) {+ k8s_chart_family(b, c->dir, fam, sizeof(fam));+ vals = k8s_helm_context(ctx, h, b, &l, c->dir, fam, NULL, &path);+ }+ int len = 0;+ char *src = vals ? k8s_repo_read(ctx, h->t[from].file, &len) : NULL;+ cbm_helm_probe_t *probes = NULL;+ int np = src ? k8s_helm_probes(h, h->t, from, to, src, (size_t)len, &probes) : 0;+ if (np > 0) {+ k8s_helm_images_of(ctx, h, b, c, from, to, vals, src, (size_t)len, probes, np, &uses);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ from = to;+ }+ k8s_helm_emit_uses(ctx, h, &uses);+ h->dflt = uses; /* the release views compare against these */+ k8s_free_index(l.charts);+}++/* ── Release images ───────────────────────────────────────────────────+ *+ * A release (a Flux HelmRelease's spec.values, a kustomize helmCharts+ * entry's valuesFile + valuesInline, a Terraform helm_release's values ++ * set) renders its chart with its values over the defaults. Of a chart in+ * the repository the templates render again: each image that differs from+ * the defaults' is the release's own -- release -DEPLOYS {via, ref: image,+ * image, override_of: the keys it set that the image read}-> Image. A chart+ * outside the repository has no templates here: its images are read from the+ * release values by convention -- a mapping with `repository` (and `tag` /+ * `digest` / `registry`) whose reference names a registry host; one without+ * a host names none (no host is invented) -- {inferred: values, values_key}. */++/* The chart dir of local Chart node `cn` (a werf chart: its `.helm`). */+static bool k8s_helm_chart_dir(const cbm_gbuf_node_t *cn, char *out, size_t sz) {+ if (!cn->file_path) {+ return false;+ }+ k8s_dirname(cn->file_path, out, sz);+ const char *base = k8s_basename(cn->file_path);+ if (strcmp(base, "werf.yaml") == 0 || strcmp(base, "werf.yml") == 0) {+ size_t l = strlen(out);+ snprintf(out + l, sz - l, "%s.helm", l ? "/" : "");+ }+ return true;+}++/* A local chart's images rendered with release values `rv`, against the+ * defaults. */+static void k8s_helm_release_local(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b, k8s_helm_t *h,+ k8s_dep_link_t *l, int64_t src, const char *via, const char *top,+ yyjson_mut_val *rv, k8s_himgs_t *emitted) {+ size_t tl = strlen(top);+ for (int from = 0; from < h->nt;) {+ int to = from + SKIP_ONE;+ while (to < h->nt && strcmp(h->t[to].file, h->t[from].file) == 0) {+ to++;+ }+ char dir[CBM_SZ_1K];+ bool in =+ k8s_chart_of(b, h->t[from].file, dir, sizeof(dir)) &&+ (strcmp(dir, top) == 0 || (tl == 0 || (strncmp(dir, top, tl) == 0 && dir[tl] == '/')));+ k8s_hchart_t *c = in ? k8s_helm_chart(ctx, h, l, dir) : NULL;+ const char *path = NULL;+ yyjson_mut_val *vals = c ? k8s_helm_context(ctx, h, b, l, dir, top, rv, &path) : NULL;+ int len = 0;+ char *srcs = vals ? k8s_repo_read(ctx, h->t[from].file, &len) : NULL;+ cbm_helm_probe_t *probes = NULL;+ int np = srcs ? k8s_helm_probes(h, h->t, from, to, srcs, (size_t)len, &probes) : 0;+ if (np > 0) {+ k8s_himgs_t got = {0};+ k8s_helm_images_of(ctx, h, b, c, from, to, vals, srcs, (size_t)len, probes, np, &got);+ yyjson_mut_val *overlay = path && path[0] ? k8s_helm_dig(rv, path) : rv;+ yyjson_mut_val *globals = yyjson_mut_obj_get(rv, "global");+ k8s_helm_emit_overrides(ctx, h, src, via, &h->dflt, &got, overlay, globals,+ path && path[0] ? path : NULL, emitted);+ cbm_free(CBM_MEM_CLASS_OTHER, got.v);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, srcs);+ from = to;+ }+}++/* Does image reference `ref` name a registry host (its first path part has+ * a `.` or `:`, or is localhost)? */+static bool k8s_helm_has_host(const char *ref) {+ const char *slash = strchr(ref, '/');+ if (!slash) {+ return false;+ }+ size_t fl = (size_t)(slash - ref);+ return memchr(ref, '.', fl) || memchr(ref, ':', fl) ||+ (fl == strlen("localhost") && strncmp(ref, "localhost", fl) == 0);+}++/* The images release values `v` name by convention (see above). */+static void k8s_helm_convention(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h, int64_t src,+ const char *via, yyjson_mut_val *v, const char *path,+ k8s_himgs_t *emitted) {+ size_t idx, max;+ if (yyjson_mut_is_arr(v)) {+ yyjson_mut_val *it;+ yyjson_mut_arr_foreach(v, idx, max, it) {+ k8s_helm_convention(ctx, h, src, via, it,+ cbm_arena_sprintf(&h->a, "%s[%zu]", path ? path : "", idx),+ emitted);+ }+ return;+ }+ if (!yyjson_mut_is_obj(v)) {+ return;+ }+ yyjson_mut_val *repo = yyjson_mut_obj_get(v, "repository");+ if (yyjson_mut_is_str(repo) && yyjson_mut_get_len(repo) > 0) {+ char reg[CBM_SZ_512] = "";+ char tag[CBM_SZ_256] = "";+ char dig[CBM_SZ_256] = "";+ yyjson_mut_val *r = yyjson_mut_obj_get(v, "registry");+ yyjson_mut_val *tg = yyjson_mut_obj_get(v, "tag");+ yyjson_mut_val *dg = yyjson_mut_obj_get(v, "digest");+ bool ok = (!r || yyjson_mut_is_null(r) || cbm_helm_scalar_text(r, reg, sizeof(reg))) &&+ (!tg || yyjson_mut_is_null(tg) || cbm_helm_scalar_text(tg, tag, sizeof(tag))) &&+ (!dg || yyjson_mut_is_null(dg) || cbm_helm_scalar_text(dg, dig, sizeof(dig)));+ const char *ref = ok ? cbm_arena_sprintf(&h->a, "%s%s%s%s%s", reg, reg[0] ? "/" : "",+ yyjson_mut_get_str(repo),+ dig[0] ? "@"+ : tag[0] ? ":"+ : "",+ dig[0] ? dig : tag)+ : NULL;+ int64_t img = ref && k8s_helm_has_host(ref) && cbm_image_ref_valid(ref)+ ? cbm_pipeline_image_node(ctx, ref)+ : 0;+ int before = emitted->n;+ if (img > 0) {+ k8s_himg_push(emitted, (k8s_himg_t){src, img, ref, NULL, NULL});+ }+ if (emitted->n > before) {+ char esc[CBM_SZ_1K];+ char kesc[CBM_SZ_1K];+ cbm_json_escape(esc, (int)sizeof(esc), ref);+ cbm_json_escape(kesc, (int)sizeof(kesc), path ? path : "");+ const char *props = cbm_arena_sprintf(+ &h->a,+ "{\"via\":\"%s\",\"ref\":\"image\",\"image\":\"%s\",\"inferred\":\"values\","+ "\"values_key\":\"%s\"}",+ via, esc, kesc);+ if (props) {+ cbm_gbuf_insert_edge(ctx->gbuf, src, img, "DEPLOYS", props);+ h->edges++;+ }+ }+ }+ yyjson_mut_val *k;+ yyjson_mut_val *child;+ yyjson_mut_obj_foreach(v, idx, max, k, child) {+ if (!yyjson_mut_is_obj(child) && !yyjson_mut_is_arr(child)) {+ continue;+ }+ const char *key = yyjson_mut_get_str(k);+ const char *cp = path && path[0] ? cbm_arena_sprintf(&h->a, "%s.%s", path, key)+ : cbm_arena_strdup(&h->a, key);+ k8s_helm_convention(ctx, h, src, via, child, cp, emitted);+ }+}++/* One release of Chart node `chart` with values `rv`. */+static void k8s_helm_release(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b, k8s_helm_t *h,+ k8s_dep_link_t *l, int64_t src, const char *via, int64_t chart,+ yyjson_mut_val *rv) {+ const cbm_gbuf_node_t *cn = chart > 0 ? cbm_gbuf_find_by_id(ctx->gbuf, chart) : NULL;+ if (!cn || !yyjson_mut_is_obj(rv) || src <= 0) {+ return;+ }+ k8s_himgs_t emitted = {0};+ char dir[CBM_SZ_1K];+ if (cbm_pipeline_chart_is_external(cn)) {+ k8s_helm_convention(ctx, h, src, via, rv, NULL, &emitted);+ } else if (k8s_helm_chart_dir(cn, dir, sizeof(dir)) && b->charts &&+ cbm_ht_get(b->charts, dir)) {+ k8s_helm_release_local(ctx, b, h, l, src, via, dir, rv, &emitted);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, emitted.v);+}++/* A node's document (lines start_line..end_line of its file) as values. */+static yyjson_mut_val *k8s_helm_node_yaml(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h,+ const cbm_gbuf_node_t *n) {+ int len = 0;+ char *src = n->file_path ? k8s_repo_read(ctx, n->file_path, &len) : NULL;+ if (!src) {+ return NULL;+ }+ size_t b = 0;+ size_t e = (size_t)len;+ int line = SKIP_ONE;+ for (size_t i = 0; i < (size_t)len && n->start_line > 0; i++) {+ if (src[i] != '\n') {+ continue;+ }+ line++;+ if (line == n->start_line) {+ b = i + SKIP_ONE;+ }+ if (n->end_line > 0 && line == n->end_line + SKIP_ONE) {+ e = i;+ break;+ }+ }+ yyjson_mut_val *v = b <= e ? cbm_helm_values_parse(h->doc, src + b, e - b) : NULL;+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ return v;+}++/* String property `key` of edge properties `props` into out; false: none. */+static bool k8s_json_str(const char *props, const char *key, char *out, size_t sz) {+ out[0] = '\0';+ yyjson_doc *d = props ? yyjson_read(props, strlen(props), 0) : NULL;+ yyjson_val *v = d ? yyjson_obj_get(yyjson_doc_get_root(d), key) : NULL;+ bool ok = yyjson_is_str(v);+ if (ok) {+ snprintf(out, sz, "%s", yyjson_get_str(v));+ }+ if (d) {+ yyjson_doc_free(d);+ }+ return ok;+}++/* A kustomize helmCharts entry's values: valuesFile, then valuesInline over+ * it; NULL when neither. */+static yyjson_mut_val *k8s_helm_kustomize_values(cbm_pipeline_ctx_t *ctx, k8s_helm_t *h,+ const cbm_gbuf_node_t *kust, const char *props) {+ char chart[CBM_SZ_512] = "";+ char release[CBM_SZ_512] = "";+ char vfile[CBM_SZ_1K] = "";+ (void)k8s_json_str(props, "chart", chart, sizeof(chart));+ (void)k8s_json_str(props, "release", release, sizeof(release));+ (void)k8s_json_str(props, "values", vfile, sizeof(vfile));+ int len = 0;+ char *src = kust->file_path ? k8s_repo_read(ctx, kust->file_path, &len) : NULL;+ yyjson_mut_val *doc = src ? cbm_helm_values_parse(h->doc, src, (size_t)len) : NULL;+ cbm_free(CBM_MEM_CLASS_OTHER, src);+ yyjson_mut_val *charts = yyjson_mut_is_obj(doc) ? yyjson_mut_obj_get(doc, "helmCharts") : NULL;+ yyjson_mut_val *inline_vals = NULL;+ size_t idx, max;+ yyjson_mut_val *c;+ yyjson_mut_arr_foreach(charts, idx, max, c) {+ const char *name = k8s_helm_meta_str(c, "name");+ const char *rel = k8s_helm_meta_str(c, "releaseName");+ if (name && strcmp(name, chart) == 0 &&+ (!release[0] || (rel && strcmp(rel, release) == 0))) {+ inline_vals = yyjson_mut_obj_get(c, "valuesInline");+ break;+ }+ }+ yyjson_mut_val *file_vals = NULL;+ if (vfile[0]) {+ int fl = 0;+ char *fs = k8s_repo_read(ctx, vfile, &fl);+ file_vals = fs ? cbm_helm_values_parse(h->doc, fs, (size_t)fl) : NULL;+ cbm_free(CBM_MEM_CLASS_OTHER, fs);+ }+ if (!inline_vals && !file_vals) {+ return NULL;+ }+ return cbm_helm_values_coalesce(h->doc, file_vals, inline_vals);+}++/* Every release's images: HelmReleases and kustomize helmCharts from their+ * DEPLOYS edges to a Chart, Terraform helm_releases from the context. */+static void k8s_helm_link_releases(cbm_pipeline_ctx_t *ctx, k8s_bundles_t *b, k8s_helm_t *h) {+ k8s_dep_link_t l = {.ctx = ctx, .charts = k8s_index_by_file(ctx, "Chart")};+ const cbm_gbuf_edge_t **es = NULL;+ int n = 0;+ if (ctx->repo_path && cbm_gbuf_find_edges_by_type(ctx->gbuf, "DEPLOYS", &es, &n) == 0) {+ /* collected first: release edges are DEPLOYS too */+ typedef struct {+ int64_t src;+ int64_t tgt;+ const char *props;+ } k8s_rel_t;+ k8s_rel_t *rels = n ? cbm_arena_alloc(&h->a, (size_t)n * sizeof(*rels)) : NULL;+ int nr = 0;+ for (int i = 0; rels && i < n; i++) {+ const char *p = es[i]->properties_json;+ if (p &&+ (strstr(p, "\"via\":\"helmrelease\"") || strstr(p, "\"via\":\"helmcharts\"")) &&+ !strstr(p, "\"ref\":")) {+ rels[nr++] =+ (k8s_rel_t){es[i]->source_id, es[i]->target_id, cbm_arena_strdup(&h->a, p)};+ }+ }+ for (int i = 0; i < nr; i++) {+ const cbm_gbuf_node_t *src = cbm_gbuf_find_by_id(ctx->gbuf, rels[i].src);+ if (!src) {+ continue;+ }+ bool hr = strstr(rels[i].props, "\"via\":\"helmrelease\"") != NULL;+ yyjson_mut_val *rv = NULL;+ if (hr) {+ yyjson_mut_val *docv = k8s_helm_node_yaml(ctx, h, src);+ yyjson_mut_val *spec =+ yyjson_mut_is_obj(docv) ? yyjson_mut_obj_get(docv, "spec") : NULL;+ rv = yyjson_mut_is_obj(spec) ? yyjson_mut_obj_get(spec, "values") : NULL;+ } else {+ rv = k8s_helm_kustomize_values(ctx, h, src, rels[i].props);+ }+ k8s_helm_release(ctx, b, h, &l, rels[i].src, hr ? "helmrelease" : "helmcharts",+ rels[i].tgt, rv);+ }+ }+ for (int i = 0; i < ctx->tf_release_n; i++) {+ cbm_tf_release_t *r = &ctx->tf_releases[i];+ if (r->values) {+ yyjson_doc *jd = yyjson_read(r->values, strlen(r->values), 0);+ yyjson_mut_val *rv = jd ? yyjson_val_mut_copy(h->doc, yyjson_doc_get_root(jd)) : NULL;+ if (jd) {+ yyjson_doc_free(jd);+ }+ k8s_helm_release(ctx, b, h, &l, r->src, "terraform", r->chart, rv);+ cbm_free(CBM_MEM_CLASS_OTHER, r->values);+ }+ }+ cbm_free(CBM_MEM_CLASS_OTHER, ctx->tf_releases);+ ctx->tf_releases = NULL;+ ctx->tf_release_n = 0;+ ctx->tf_release_cap = 0;+ k8s_free_index(l.charts);+}++static void k8s_helm_init(k8s_helm_t *h) {+ *h = (k8s_helm_t){0};+ cbm_arena_init_lazy(&h->a, CBM_SZ_4K);+ h->doc = yyjson_mut_doc_new(cbm_json_writer_allocator());+ h->charts = cbm_ht_create(0);+ h->defines = cbm_ht_create(0);+}++static void k8s_helm_free(k8s_helm_t *h) {+ if (h->defines) {+ cbm_ht_foreach(h->defines, k8s_helm_free_defines, NULL);+ cbm_ht_free(h->defines);+ }+ if (h->charts) {+ cbm_ht_free(h->charts);+ }+ if (h->doc) {+ yyjson_mut_doc_free(h->doc);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, h->t);+ cbm_free(CBM_MEM_CLASS_OTHER, h->dflt.v);+ cbm_arena_destroy(&h->a);+ if (h->edges > 0) {+ cbm_log_info("pass.k8s.helm_images", "edges", itoa_k8s(h->edges));+ }+ *h = (k8s_helm_t){0};+}++/* Each Image a chart's objects use (their USAGE {ref: image}, after* pass_docker.c moved references onto component Images): Chart -DEPLOYS- * {via: chart, ref: image}-> it. A templated image names no Image, and no- * values default is read. Edges are collected first: inserting while walking- * a chart's own DEPLOYS edges would grow the list being read. */+ * {via: chart, ref: image}-> it -- {default_of: the values keys} when every+ * object of the chart uses it by a rendered default (the keys unioned), none+ * when one names it literally. Edges are collected first: inserting while+ * walking a chart's own DEPLOYS edges would grow the list being read. */+typedef struct {+ int64_t chart;+ int64_t img;+ bool literal;+ char *keys; /* JSON array (cbm_alloc); NULL: none yet */+} k8s_cimg_t;++/* JSON array `a` (owned, may be NULL) with the strings of JSON array `b`+ * appended once; the result is owned. */+static char *k8s_keys_union(char *a, const char *b) {+ yyjson_doc *db = b ? yyjson_read(b, strlen(b), 0) : NULL;+ yyjson_val *bv = db ? yyjson_doc_get_root(db) : NULL;+ size_t idx, max;+ yyjson_val *k;+ yyjson_arr_foreach(bv, idx, max, k) {+ const char *s = yyjson_get_str(k);+ if (!s) {+ continue;+ }+ char esc[CBM_SZ_1K];+ char quoted[CBM_SZ_1K + PAIR_LEN + PAIR_LEN];+ cbm_json_escape(esc, (int)sizeof(esc), s);+ snprintf(quoted, sizeof(quoted), "\"%s\"", esc);+ if (a && strstr(a, quoted)) {+ continue;+ }+ size_t al = a ? strlen(a) : 0;+ char *g = cbm_alloc(CBM_MEM_CLASS_OTHER, al + strlen(quoted) + 3);+ if (!g) {+ break;+ }+ if (a) {+ snprintf(g, al + strlen(quoted) + 3, "%.*s,%s]", (int)(al - SKIP_ONE), a, quoted);+ } else {+ snprintf(g, strlen(quoted) + 3, "[%s]", quoted);+ }+ cbm_free(CBM_MEM_CLASS_OTHER, a);+ a = g;+ }+ if (db) {+ yyjson_doc_free(db);+ }+ return a;+}+static void k8s_link_chart_images(cbm_pipeline_ctx_t *ctx) {const cbm_gbuf_node_t **charts = NULL;int nc = 0;if (cbm_gbuf_find_by_label(ctx->gbuf, "Chart", &charts, &nc) != 0 || nc == 0) {return;}- int64_t *pairs = NULL;- int np = 0;+ k8s_cimg_t *v = NULL;+ int n = 0;int cap = 0;for (int c = 0; c < nc; c++) {const cbm_gbuf_edge_t **dep = NULL;@@ -3748,26 +4915,41 @@ static void k8s_link_chart_images(cbm_pipeline_ctx_t *ctx) {!strstr(up, "\"ref\":\"image\"")) {continue;}- if (np + PAIR_LEN > cap) {- int ncap = cap ? cap * PAIR_LEN : CBM_SZ_64;- int64_t *grown =- cbm_realloc(CBM_MEM_CLASS_OTHER, pairs, (size_t)ncap * sizeof(*pairs));- if (!grown) {+ int at = -SKIP_ONE;+ for (int i = n - SKIP_ONE; i >= 0 && at < 0; i--) {+ at = v[i].chart == charts[c]->id && v[i].img == img->id ? i : at;+ }+ if (at < 0) {+ if (!k8s_grow((void **)&v, &cap, n, sizeof(*v))) {break;}- pairs = grown;- cap = ncap;+ v[n] = (k8s_cimg_t){charts[c]->id, img->id, false, NULL};+ at = n++;+ }+ const char *dflt = strstr(up, "\"default_of\":");+ if (!dflt) {+ v[at].literal = true;+ } else {+ char keys[CBM_SZ_4K];+ const char *arr = dflt + strlen("\"default_of\":");+ const char *end = strchr(arr, ']');+ if (end && (size_t)(end - arr) + PAIR_LEN < sizeof(keys)) {+ snprintf(keys, sizeof(keys), "%.*s", (int)(end - arr + SKIP_ONE), arr);+ v[at].keys = k8s_keys_union(v[at].keys, keys);+ }}- pairs[np++] = charts[c]->id;- pairs[np++] = img->id;}}}- for (int i = 0; i + SKIP_ONE < np; i += PAIR_LEN) {- cbm_gbuf_insert_edge(ctx->gbuf, pairs[i], pairs[i + SKIP_ONE], "DEPLOYS",- "{\"via\":\"chart\",\"ref\":\"image\"}");+ for (int i = 0; i < n; i++) {+ char props[CBM_SZ_4K];+ bool marked = !v[i].literal && v[i].keys;+ snprintf(props, sizeof(props), "{\"via\":\"chart\",\"ref\":\"image\"%s%s}",+ marked ? ",\"default_of\":" : "", marked ? v[i].keys : "");+ cbm_gbuf_insert_edge(ctx->gbuf, v[i].chart, v[i].img, "DEPLOYS", props);+ cbm_free(CBM_MEM_CLASS_OTHER, v[i].keys);}- cbm_free(CBM_MEM_CLASS_OTHER, pairs);+ cbm_free(CBM_MEM_CLASS_OTHER, v);}/* A HelmRelease whose chartRef names OCIRepository `oci` (its USAGE edge@@ -3830,7 +5012,7 @@ static void k8s_prop_add(char *out, size_t out_sz, int *w, const char *key, cons* namespace, values, line} from the kustomization (its Kustomization* Resource, else its File -- the unit a Flux / Argo deploy reaches) to the* external Chart of that repository and name. */-static void k8s_link_kcharts(k8s_dep_link_t *l, const k8s_facts_t *f) {+static void k8s_link_kcharts(k8s_dep_link_t *l, k8s_bundles_t *b, const k8s_facts_t *f) {for (int i = 0; i < f->kchart_n; i++) {const k8s_kchart_t *c = &f->kcharts[i];if (!c->chart || strchr(c->chart, '/') || strchr(c->chart, '$')) {@@ -3838,8 +5020,18 @@ static void k8s_link_kcharts(k8s_dep_link_t *l, const k8s_facts_t *f) {}int64_t src = k8s_first_id(l->kusts, c->kust);src = src > 0 ? src : k8s_first_id(l->files, c->kust);+ /* No repo: the chart in the kustomization's chartHome (charts/). */+ int64_t local = 0;+ if (!c->url || !c->url[0]) {+ char kdir[CBM_SZ_1K];+ char cdir[CBM_SZ_1K];+ k8s_dirname(c->kust, kdir, sizeof(kdir));+ snprintf(cdir, sizeof(cdir), "%s%scharts/%s", kdir, kdir[0] ? "/" : "", c->chart);+ local = b->charts && cbm_ht_get(b->charts, cdir) ? k8s_chart_node(l, cdir) : 0;+ }char props[CBM_SZ_4K];- int w = snprintf(props, sizeof(props), "{\"via\":\"helmcharts\",\"external\":true");+ int w = snprintf(props, sizeof(props), "{\"via\":\"helmcharts\"%s",+ local > 0 ? "" : ",\"external\":true");k8s_prop_add(props, sizeof(props), &w, "chart", c->chart);k8s_prop_add(props, sizeof(props), &w, "url", c->url);k8s_prop_add(props, sizeof(props), &w, "version", c->version);@@ -3850,7 +5042,8 @@ static void k8s_link_kcharts(k8s_dep_link_t *l, const k8s_facts_t *f) {continue;}snprintf(props + w, sizeof(props) - (size_t)w, ",\"line\":%d}", c->line);- k8s_deploys_edge(l, src, k8s_external_chart(l, c->chart, c->url, c->kust), props);+ k8s_deploys_edge(+ l, src, local > 0 ? local : k8s_external_chart(l, c->chart, c->url, c->kust), props);}}@@ -4527,7 +5720,7 @@ static void k8s_link_deploys(cbm_pipeline_ctx_t *ctx, k8s_kusts_t *ks, k8s_bundlk8s_link_chart_refs(&l, &f->srcs[s]);}if (l.files && l.kusts) {- k8s_link_kcharts(&l, f);+ k8s_link_kcharts(&l, b, f);}cbm_free(CBM_MEM_CLASS_OTHER, (void *)members.items);cbm_free(CBM_MEM_CLASS_OTHER, (void *)units.items);@@ -4603,6 +5796,14 @@ int cbm_pipeline_pass_k8s(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *files,k8s_chart_dir_add(&bundles, rel);helm_count++;break;+ case K8S_WERF: {+ char chart_dir[CBM_SZ_1K];+ if (handle_werf_chart(ctx, rel, p->source, chart_dir, sizeof(chart_dir))) {+ k8s_chart_dir_register(&bundles, chart_dir);+ helm_count++;+ }+ break;+ }case K8S_KUSTOMIZE:k8s_kusts_push(&kusts, rel, p->source);k8s_kustomize_keep(&facts, rel, p->res);@@ -4647,6 +5848,9 @@ int cbm_pipeline_pass_k8s(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *files,k8s_link_crds(ctx, &bundles, &facts);k8s_link_deploys(ctx, &kusts, &bundles, &facts);k8s_link_images(ctx, &facts);+ k8s_helm_t helm;+ k8s_helm_init(&helm);+ k8s_helm_collect(ctx, &facts, &helm);k8s_link_envs(ctx, &facts);k8s_link_patches(ctx, &kusts, &facts);k8s_link_renames(ctx, &kusts);@@ -4657,11 +5861,17 @@ int cbm_pipeline_pass_k8s(cbm_pipeline_ctx_t *ctx, const cbm_file_info_t *files,k8s_link_local_deps(ctx, &local_deps);k8s_link_includes(ctx, &bundles, files, file_count);k8s_link_chart_contents(ctx, &bundles);- k8s_bundles_free(&bundles);+ /* The images chart templates render with their values (helm_template.c). */+ k8s_helm_link_defaults(ctx, &bundles, &helm);k8s_kusts_free(&kusts);/* Shell and Make deploy commands, against the nodes linked above. */cbm_pipeline_pass_shell(ctx, files, file_count);cbm_pipeline_pass_terraform(ctx, files, file_count);+ /* The images releases render (their values over the charts' defaults),+ * before the image hubs move references. */+ k8s_helm_link_releases(ctx, &bundles, &helm);+ k8s_helm_free(&helm);+ k8s_bundles_free(&bundles);cbm_pipeline_pass_ansible(ctx, files, file_count);cbm_pipeline_pass_docker(ctx, files, file_count);/* The Images a chart's objects use, once the image hubs moved them. */diff --git a/src/pipeline/pass_shell.c b/src/pipeline/pass_shell.cindex 8e6f82ce9..e3a1e768a 100644--- a/src/pipeline/pass_shell.c+++ b/src/pipeline/pass_shell.c@@ -376,10 +376,12 @@ typedef struct {const char *ci; /* static: the CI running the command; NULL: none */const char *job; /* pass-arena: its job; NULL: none */bool chart;- bool spawn; /* SPAWNS the script `tgt` / the Process `ext`, not DEPLOYS */- bool make; /* SPAWNS the rule of target `ext` that makefile `path` reads */- bool build; /* the image `ext` is built from the Dockerfile `path` */- bool http; /* HTTP_CALLS the URL `ext` (scheme://host/path) with method `path` */+ bool spawn; /* SPAWNS the script `tgt` / the Process `ext`, not DEPLOYS */+ bool make; /* SPAWNS the rule of target `ext` that makefile `path` reads */+ bool build; /* the image `ext` is built from the Dockerfile `path` */+ bool http; /* HTTP_CALLS the URL `ext` (scheme://host/path) with method `path` */+ const char *build_args; /* pass-arena, build: --build-arg as a JSON object; NULL: none */+ const char *default_of; /* pass-arena, build: JSON array of the ${X:-d} defaults naming `ext` */} sh_hit_t;typedef struct {@@ -413,9 +415,10 @@ typedef struct {const char *s; /* scalar value; NULL: unknown */const char **items; /* array items (an item NULL: unknown); NULL: no array */int n;+ const char *dflt_of; /* JSON array: the variables whose ${X:-d} default made it */} sh_val_t;-static const sh_val_t SH_UNKNOWN_VAL = {NULL, NULL, 0};+static const sh_val_t SH_UNKNOWN_VAL = {NULL, NULL, 0, NULL};typedef enum { SH_FREE, SH_AT, SH_LOST } sh_cwd_mode_t;@@ -464,8 +467,38 @@ typedef struct {sh_cwd_t *dirs; /* pushd stack */int ndirs;int cap_dirs;+ /* While set, an evaluation adds to dflt_acc (a JSON array) the variables+ * whose ${X:-d} default supplied its value. */+ bool dflt_track;+ const char *dflt_acc;} sh_t;+/* JSON array `list` (NULL: empty) with identifier `name` appended once. */+static const char *sh_names_add(CBMArena *a, const char *list, const char *name, size_t nl) {+ if (!list) {+ return cbm_arena_sprintf(a, "[\"%.*s\"]", (int)nl, name);+ }+ char quoted[CBM_SZ_256];+ snprintf(quoted, sizeof(quoted), "\"%.*s\"", (int)nl, name);+ if (strstr(list, quoted)) {+ return list;+ }+ return cbm_arena_sprintf(a, "%.*s,%s]", (int)(strlen(list) - SKIP_ONE), list, quoted);+}++/* JSON array `a` with the names of JSON array `b` appended once. */+static const char *sh_names_union(CBMArena *ar, const char *a, const char *b) {+ for (const char *p = b ? strchr(b, '"') : NULL; p;) {+ const char *e = strchr(p + SKIP_ONE, '"');+ if (!e) {+ break;+ }+ a = sh_names_add(ar, a, p + SKIP_ONE, (size_t)(e - p - SKIP_ONE));+ p = strchr(e + SKIP_ONE, '"');+ }+ return a;+}+static void sh_set(sh_t *s, const char *name, const sh_val_t *v, bool local) {if (!sh_grow((void **)&s->undo, &s->cap_undo, s->nundo, sizeof(*s->undo))) {return;@@ -622,14 +655,14 @@ static const sh_val_t *sh_lookup(sh_t *s, const char *name, bool *found) {}sh_val_t *v = cbm_arena_alloc(s->a, sizeof(*v));if (v) {- *v = (sh_val_t){s->script, NULL, 0};+ *v = (sh_val_t){s->script, NULL, 0, NULL};}return v ? v : &SH_UNKNOWN_VAL;}if (strcmp(name, "PWD") == 0) {sh_val_t *v = cbm_arena_alloc(s->a, sizeof(*v));if (v) {- *v = (sh_val_t){sh_cwd_value(s), NULL, 0};+ *v = (sh_val_t){sh_cwd_value(s), NULL, 0, NULL};}return v ? v : &SH_UNKNOWN_VAL;}@@ -745,20 +778,29 @@ static const char *sh_eval_expansion(sh_t *s, TSNode n) {val = v->n > 0 ? v->items[0] : "";}if (!op) {+ if (found && s->dflt_track) {+ s->dflt_acc = sh_names_union(s->a, s->dflt_acc, v->dflt_of);+ }return found ? val : NULL;}bool colon = op[0] == ':';bool use_default = !found || (colon && val && !val[0]);if (!use_default) {+ if (s->dflt_track) {+ s->dflt_acc = sh_names_union(s->a, s->dflt_acc, v->dflt_of);+ }return val;}sh_str_t b = {0};sh_concat(s, &b, n, op_end, close, true);const char *d = sh_str_done(&b);+ if (s->dflt_track) {+ s->dflt_acc = sh_names_add(s->a, s->dflt_acc, nm, strlen(nm));+ }if (d && strchr(op, '=')) {sh_val_t *nv = cbm_arena_alloc(s->a, sizeof(*nv));if (nv) {- *nv = (sh_val_t){d, NULL, 0};+ *nv = (sh_val_t){d, NULL, 0, sh_names_add(s->a, NULL, nm, strlen(nm))};sh_set(s, nm, nv, false);}}@@ -943,6 +985,9 @@ static const char *sh_eval(sh_t *s, TSNode n) {}bool found = false;const sh_val_t *val = sh_lookup(s, nm, &found);+ if (found && s->dflt_track) {+ s->dflt_acc = sh_names_union(s->a, s->dflt_acc, val->dflt_of);+ }return found ? val->s : NULL;}if (strcmp(t, "expansion") == 0) {@@ -1319,6 +1364,8 @@ static void sh_hit_push(sh_t *s, TSNode cmd, sh_hit_t x) {x.line = (int)ts_node_start_point(cmd).row + SKIP_ONE + s->line_base;x.ext = x.ext ? cbm_arena_strdup(&h->arena, x.ext) : NULL;x.path = x.path ? cbm_arena_strdup(&h->arena, x.path) : NULL;+ x.build_args = x.build_args ? cbm_arena_strdup(&h->arena, x.build_args) : NULL;+ x.default_of = x.default_of ? cbm_arena_strdup(&h->arena, x.default_of) : NULL;x.ci = s->ci;x.job = s->job ? cbm_arena_strdup(&h->arena, s->job) : NULL;h->items[h->count++] = x;@@ -2268,7 +2315,11 @@ static void sh_assign(sh_t *s, TSNode n, bool local) {if (!nm || !v) {return;}- *v = (sh_val_t){"", NULL, 0};+ *v = (sh_val_t){"", NULL, 0, NULL};+ bool track = s->dflt_track;+ const char *acc = s->dflt_acc;+ s->dflt_track = true;+ s->dflt_acc = NULL;if (sh_type(value, "array")) {uint32_t cnt = ts_node_named_child_count(value);const char **items = cbm_arena_alloc(s->a, (cnt ? cnt : SKIP_ONE) * sizeof(*items));@@ -2282,10 +2333,13 @@ static void sh_assign(sh_t *s, TSNode n, bool local) {items[k++] = sh_eval_word(s, c);}}- *v = (sh_val_t){k > 0 ? items[0] : "", items, k};+ *v = (sh_val_t){k > 0 ? items[0] : "", items, k, NULL};} else if (!ts_node_is_null(value)) {v->s = sh_eval(s, value);}+ v->dflt_of = s->dflt_acc;+ s->dflt_track = track;+ s->dflt_acc = acc;bool append = false;for (uint32_t i = 0; i < ts_node_child_count(n); i++) {TSNode c = ts_node_child(n, i);@@ -2434,6 +2488,54 @@ static const char *sh_image_repo(sh_t *s, TSNode cmd, const sh_argv_t *a, int i)return sh_str_done(&out);}+/* JSON object `json` (NULL: none) with build argument `kv` ("K=V") added; a+ * `K` alone (the environment's value) or an unknown word adds nothing. */+static const char *sh_build_arg(sh_t *s, const char *json, const char *kv) {+ const char *eq = kv ? strchr(kv, '=') : NULL;+ if (!eq || eq == kv) {+ return json;+ }+ for (const char *p = kv; p < eq; p++) {+ if (!isalnum((unsigned char)*p) && *p != '_') {+ return json;+ }+ }+ char ev[CBM_SZ_1K];+ cbm_json_escape(ev, (int)sizeof(ev), eq + SKIP_ONE);+ const char *pair = cbm_arena_sprintf(s->a, "\"%.*s\":\"%s\"", (int)(eq - kv), kv, ev);+ if (!pair) {+ return json;+ }+ return json ? cbm_arena_sprintf(s->a, "%.*s,%s}", (int)(strlen(json) - SKIP_ONE), json, pair)+ : cbm_arena_sprintf(s->a, "{%s}", pair);+}++/* The variables whose ${X:-d} default supplied argv word `i` (a JSON array,+ * NULL: none): the word evaluated once more with the defaults recorded. */+static const char *sh_word_defaults(sh_t *s, TSNode cmd, const sh_argv_t *a, int i) {+ uint32_t b = a->span[(size_t)i * PAIR_LEN];+ uint32_t e = a->span[(size_t)i * PAIR_LEN + SKIP_ONE];+ if (!memchr(s->src + b, '$', e - b)) {+ return NULL;+ }+ TSNode w = ts_node_descendant_for_byte_range(cmd, b, e);+ while (!ts_node_is_null(w) && (ts_node_start_byte(w) != b || ts_node_end_byte(w) != e)) {+ w = ts_node_parent(w);+ }+ if (ts_node_is_null(w)) {+ return NULL;+ }+ bool track = s->dflt_track;+ const char *acc = s->dflt_acc;+ s->dflt_track = true;+ s->dflt_acc = NULL;+ (void)sh_eval_word(s, w);+ const char *out = s->dflt_acc;+ s->dflt_track = track;+ s->dflt_acc = acc;+ return out;+}+/* docker / podman / nerdctl [buildx | image | builder] build, buildah bud:* each tagged image is built from the Dockerfile -f names (against the cwd),* else <context>/Dockerfile -- one file of the repository. */@@ -2467,17 +2569,20 @@ static void sh_build(sh_t *s, TSNode cmd, const sh_argv_t *a) {cbm_ht_set(s->hits->declarers, s->file, (void *)s->file);}int tags[SH_BUILD_TAGS];+ int tag_words[SH_BUILD_TAGS];const char *tag_vals[SH_BUILD_TAGS];int nt = 0;const char *dfile = NULL;bool dfile_known = true;const char *ctx = NULL;bool ctx_seen = false;+ const char *args = NULL;for (; i < a->n; i++) {const char *w = a->v[i];if (w && (sh_eq(w, "-t") || sh_eq(w, "--tag")) && i + SKIP_ONE < a->n) {if (nt < SH_BUILD_TAGS) {tags[nt] = i + SKIP_ONE;+ tag_words[nt] = i + SKIP_ONE;tag_vals[nt++] = a->v[i + SKIP_ONE];}i++;@@ -2485,9 +2590,15 @@ static void sh_build(sh_t *s, TSNode cmd, const sh_argv_t *a) {dfile = a->v[i + SKIP_ONE];dfile_known = dfile != NULL;i++;+ } else if (w && sh_eq(w, "--build-arg") && i + SKIP_ONE < a->n) {+ args = sh_build_arg(s, args, a->v[i + SKIP_ONE]);+ i++;+ } else if (w && strncmp(w, "--build-arg=", strlen("--build-arg=")) == 0) {+ args = sh_build_arg(s, args, w + strlen("--build-arg="));} else if (w && strncmp(w, "--tag=", strlen("--tag=")) == 0) {if (nt < SH_BUILD_TAGS && w[strlen("--tag=")]) {tags[nt] = -SKIP_ONE;+ tag_words[nt] = i;tag_vals[nt++] = w + strlen("--tag=");}} else if (w && strncmp(w, "--file=", strlen("--file=")) == 0) {@@ -2513,7 +2624,12 @@ static void sh_build(sh_t *s, TSNode cmd, const sh_argv_t *a) {}if (img && img[0]) {sh_hit_push(s, cmd,- (sh_hit_t){.via = "docker-build", .ext = img, .path = hit, .build = true});+ (sh_hit_t){.via = "docker-build",+ .ext = img,+ .path = hit,+ .build = true,+ .build_args = args,+ .default_of = sh_word_defaults(s, cmd, a, tag_words[k])});}}}@@ -3305,8 +3421,8 @@ static void sh_makefile(sh_pass_t *p, const char *rel, const char *src, size_t lsh_val_t *root = cbm_arena_alloc(&a, sizeof(*root));sh_val_t *cur = cbm_arena_alloc(&a, sizeof(*cur));if (root && cur) {- *root = (sh_val_t){SH_ROOT, NULL, 0};- *cur = (sh_val_t){sh_anchor(&a, s.sdir), NULL, 0};+ *root = (sh_val_t){SH_ROOT, NULL, 0, NULL};+ *cur = (sh_val_t){sh_anchor(&a, s.sdir), NULL, 0, NULL};cbm_ht_set(s.env, "__cbm_root", root);if (m.makefile) {cbm_ht_set(s.env, "__cbm_curdir", cur);@@ -3653,8 +3769,10 @@ static int sh_link_build(cbm_pipeline_ctx_t *ctx, const sh_hit_t *x, CBMHashTablsh_ci_props(x, ci, sizeof(ci));snprintf(props, sizeof(props),"{\"via\":\"build\",\"tool\":\"docker-build\",\"file\":\"%s\",\"image\":\"%s\"%s,"- "\"line\":%d}",- esc_file, esc_img, ci, x->line);+ "\"line\":%d%s%s%s%s}",+ esc_file, esc_img, ci, x->line, x->default_of ? ",\"default_of\":" : "",+ x->default_of ? x->default_of : "", x->build_args ? ",\"build_args\":" : "",+ x->build_args ? x->build_args : "");cbm_gbuf_insert_edge(ctx->gbuf, img, mod, "DEPENDS_ON", props);return SKIP_ONE;}@@ -3852,7 +3970,7 @@ typedef struct {static void sh_ci_var(sh_t *s, const char *name, const char *value) {sh_val_t *v = value ? cbm_arena_alloc(s->a, sizeof(*v)) : NULL;if (v) {- *v = (sh_val_t){value, NULL, 0};+ *v = (sh_val_t){value, NULL, 0, NULL};}sh_set(s, name, v ? v : &SH_UNKNOWN_VAL, false);}diff --git a/src/pipeline/pass_terraform.c b/src/pipeline/pass_terraform.cindex 6328311c1..443bc4961 100644--- a/src/pipeline/pass_terraform.c+++ b/src/pipeline/pass_terraform.c@@ -22,7 +22,9 @@#include "foundation/log.h"#include "foundation/mem_core.h"#include "foundation/str_util.h"+#include "foundation/json_writer.h" /* cbm_json_writer_allocator */#include "graph_buffer/graph_buffer.h"+#include "pipeline/helm_template.h"#include "pipeline/pipeline.h"#include "pipeline/pipeline_internal.h"#include "cbm.h"@@ -249,6 +251,402 @@ static bool tf_plain_name(const char *s) {}/* One `resource "helm_release" "<name>" { ... }` block. */+/* ── helm_release values (for pass_k8s.c's release images) ────────── */++/* The expression inside wrapper nodes. */+static TSNode tf_unwrap(TSNode n) {+ while (tf_type(n, "expression") || tf_type(n, "literal_value") ||+ tf_type(n, "collection_value") || tf_type(n, "template_expr")) {+ if (ts_node_named_child_count(n) != SKIP_ONE) {+ break;+ }+ n = ts_node_named_child(n, 0);+ }+ return n;+}++/* A heredoc's text (a `<<-` one dedented); NULL when it interpolates. */+static char *tf_heredoc(const tf_t *t, TSNode n) {+ TSNode open = {0};+ TSNode close = {0};+ bool dedent = false;+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ if (tf_type(c, "heredoc_start")) {+ uint32_t b = ts_node_start_byte(c);+ dedent = ts_node_end_byte(c) - b >= 3 && t->src[b + PAIR_LEN] == '-';+ } else if (tf_type(c, "heredoc_identifier")) {+ if (ts_node_is_null(open)) {+ open = c;+ } else {+ close = c;+ }+ } else if (!tf_type(c, "template_literal")) {+ return NULL; /* an interpolation or a directive: no literal */+ }+ }+ if (ts_node_is_null(open) || ts_node_is_null(close)) {+ return NULL;+ }+ const char *b = t->src + ts_node_end_byte(open);+ const char *e = t->src + ts_node_start_byte(close);+ const char *nl = memchr(b, '\n', (size_t)(e - b));+ b = nl ? nl + SKIP_ONE : e;+ while (e > b && e[-1] != '\n') {+ e--; /* the closing line's indentation */+ }+ size_t indent = (size_t)-1;+ for (const char *p = b; dedent && p < e;) {+ const char *le = memchr(p, '\n', (size_t)(e - p));+ le = le ? le : e;+ size_t sp = 0;+ while (p + sp < le && (p[sp] == ' ' || p[sp] == '\t')) {+ sp++;+ }+ if (p + sp < le && sp < indent) {+ indent = sp;+ }+ p = le + (le < e ? SKIP_ONE : 0);+ }+ if (!dedent || indent == (size_t)-1) {+ indent = 0;+ }+ char *out = cbm_alloc(CBM_MEM_CLASS_OTHER, (size_t)(e - b) + SKIP_ONE);+ size_t k = 0;+ for (const char *p = b; out && p < e;) {+ const char *le = memchr(p, '\n', (size_t)(e - p));+ le = le ? le + SKIP_ONE : e;+ size_t skip = 0;+ while (skip < indent && p + skip < le && (p[skip] == ' ' || p[skip] == '\t')) {+ skip++;+ }+ memcpy(out + k, p + skip, (size_t)(le - p) - skip);+ k += (size_t)(le - p) - skip;+ p = le;+ }+ if (out) {+ out[k] = '\0';+ }+ return out;+}++/* An HCL literal as JSON: a string without interpolation, a number, a bool,+ * null, a tuple or object of those; NULL: anything else. */+static yyjson_mut_val *tf_json(const tf_t *t, yyjson_mut_doc *doc, TSNode n) {+ n = tf_unwrap(n);+ if (tf_type(n, "string_lit") || tf_type(n, "quoted_template")) {+ char buf[CBM_SZ_4K];+ size_t len = 0;+ buf[0] = '\0';+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ if (tf_type(c, "quoted_template_start") || tf_type(c, "quoted_template_end")) {+ continue;+ }+ if (!tf_type(c, "template_literal")) {+ return NULL;+ }+ uint32_t b = ts_node_start_byte(c);+ if (!tf_add(buf, sizeof(buf), &len, t->src + b, ts_node_end_byte(c) - b)) {+ return NULL;+ }+ }+ size_t k = 0; /* \" \\ \n \t */+ for (size_t i = 0; i < len; i++) {+ if (buf[i] == '\\' && i + SKIP_ONE < len) {+ char c = buf[++i];+ buf[k++] = c == 'n' ? '\n' : c == 't' ? '\t' : c;+ } else {+ buf[k++] = buf[i];+ }+ }+ return yyjson_mut_strncpy(doc, buf, k);+ }+ if (tf_type(n, "heredoc_template")) {+ char *s = tf_heredoc(t, n);+ yyjson_mut_val *v = s ? yyjson_mut_strcpy(doc, s) : NULL;+ cbm_free(CBM_MEM_CLASS_OTHER, s);+ return v;+ }+ uint32_t b = ts_node_start_byte(n);+ uint32_t e = ts_node_end_byte(n);+ if (tf_type(n, "numeric_lit")) {+ char buf[CBM_SZ_64];+ snprintf(buf, sizeof(buf), "%.*s", (int)(e - b), t->src + b);+ return yyjson_mut_real(doc, strtod(buf, NULL));+ }+ if (tf_type(n, "bool_lit")) {+ return yyjson_mut_bool(doc, e - b == strlen("true") && strncmp(t->src + b, "true", 4) == 0);+ }+ if (tf_type(n, "null_lit")) {+ return yyjson_mut_null(doc);+ }+ if (tf_type(n, "tuple")) {+ yyjson_mut_val *arr = yyjson_mut_arr(doc);+ for (uint32_t i = 0; arr && i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ if (tf_type(c, "tuple_start") || tf_type(c, "tuple_end")) {+ continue;+ }+ yyjson_mut_val *v = tf_json(t, doc, c);+ if (!v) {+ return NULL;+ }+ yyjson_mut_arr_append(arr, v);+ }+ return arr;+ }+ if (tf_type(n, "object")) {+ yyjson_mut_val *obj = yyjson_mut_obj(doc);+ for (uint32_t i = 0; obj && i < ts_node_named_child_count(n); i++) {+ TSNode c = ts_node_named_child(n, i);+ if (!tf_type(c, "object_elem")) {+ continue;+ }+ TSNode kn = tf_unwrap(ts_node_child_by_field_name(c, "key", (uint32_t)strlen("key")));+ TSNode vn = ts_node_child_by_field_name(c, "val", (uint32_t)strlen("val"));+ yyjson_mut_val *key = NULL;+ if (tf_type(kn, "variable_expr") && ts_node_named_child_count(kn) == SKIP_ONE) {+ TSNode id = ts_node_named_child(kn, 0);+ uint32_t kb = ts_node_start_byte(id);+ key = yyjson_mut_strncpy(doc, t->src + kb, ts_node_end_byte(id) - kb);+ } else {+ key = tf_json(t, doc, kn);+ }+ yyjson_mut_val *val = tf_json(t, doc, vn);+ if (!key || !yyjson_mut_is_str(key) || !val) {+ return NULL;+ }+ (void)yyjson_mut_obj_put(obj, key, val);+ }+ return obj;+ }+ return NULL;+}++/* A repository file's text (cbm_alloc), NULL when unreadable. */+static char *tf_read_repo(const tf_t *t, const char *path, size_t *len) {+ char full[CBM_SZ_4K];+ snprintf(full, sizeof(full), "%s/%s", t->ctx->repo_path, path);+ FILE *f = cbm_fopen(full, "rb");+ if (!f) {+ return NULL;+ }+ char *buf = NULL;+ size_t cap = 0;+ char chunk[CBM_SZ_4K];+ size_t r;+ *len = 0;+ while ((r = fread(chunk, SKIP_ONE, sizeof(chunk), f)) > 0) {+ if (*len + r + SKIP_ONE > cap) {+ cap = (*len + r + SKIP_ONE) * PAIR_LEN;+ char *g = cbm_realloc(CBM_MEM_CLASS_OTHER, buf, cap);+ if (!g) {+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ (void)fclose(f);+ return NULL;+ }+ buf = g;+ }+ memcpy(buf + *len, chunk, r);+ *len += r;+ }+ (void)fclose(f);+ if (buf) {+ buf[*len] = '\0';+ }+ return buf;+}++/* A `values = [...]` item as values: a YAML string / heredoc, file(<path>)+ * of a repository file, yamlencode / jsonencode of a literal; NULL: none of+ * those. */+static yyjson_mut_val *tf_values_item(const tf_t *t, yyjson_mut_doc *doc, TSNode item, CBMArena *a,+ const char ***files, int *nfiles) {+ TSNode n = tf_unwrap(item);+ if (tf_type(n, "function_call")) {+ TSNode fn = ts_node_named_child(n, 0);+ TSNode args = {0};+ for (uint32_t i = 0; i < ts_node_named_child_count(n); i++) {+ if (tf_type(ts_node_named_child(n, i), "function_arguments")) {+ args = ts_node_named_child(n, i);+ }+ }+ if (ts_node_is_null(fn) || ts_node_is_null(args) ||+ ts_node_named_child_count(args) != SKIP_ONE) {+ return NULL;+ }+ uint32_t fb = ts_node_start_byte(fn);+ size_t fl = ts_node_end_byte(fn) - fb;+ TSNode arg = ts_node_named_child(args, 0);+ if ((fl == strlen("yamlencode") && strncmp(t->src + fb, "yamlencode", fl) == 0) ||+ (fl == strlen("jsonencode") && strncmp(t->src + fb, "jsonencode", fl) == 0)) {+ return tf_json(t, doc, arg);+ }+ if (fl == strlen("file") && strncmp(t->src + fb, "file", fl) == 0) {+ char v[CBM_SZ_1K];+ char path[CBM_SZ_1K];+ if (!t->ctx->repo_path || !tf_string(t->src, t->mdir, arg, v, sizeof(v)) ||+ !tf_repo_path(t->mdir, v, path, sizeof(path))) {+ return NULL;+ }+ const char **grown = cbm_arena_alloc(a, (size_t)(*nfiles + SKIP_ONE) * sizeof(*grown));+ if (grown) {+ if (*nfiles) {+ memcpy(grown, *files, (size_t)*nfiles * sizeof(*grown));+ }+ grown[(*nfiles)++] = cbm_arena_strdup(a, path);+ *files = grown;+ }+ size_t len = 0;+ char *buf = tf_read_repo(t, path, &len);+ yyjson_mut_val *out = buf ? cbm_helm_values_parse(doc, buf, len) : NULL;+ cbm_free(CBM_MEM_CLASS_OTHER, buf);+ return out;+ }+ return NULL;+ }+ yyjson_mut_val *s = tf_json(t, doc, n);+ return yyjson_mut_is_str(s)+ ? cbm_helm_values_parse(doc, yyjson_mut_get_str(s), yyjson_mut_get_len(s))+ : NULL;+}++/* A `set` entry (name / value / type) applied to root; false when it is no+ * literal. */+static bool tf_set_entry(yyjson_mut_doc *doc, yyjson_mut_val *root, yyjson_mut_val *entry) {+ yyjson_mut_val *nm = yyjson_mut_obj_get(entry, "name");+ yyjson_mut_val *val = yyjson_mut_obj_get(entry, "value");+ yyjson_mut_val *ty = yyjson_mut_obj_get(entry, "type");+ if (!yyjson_mut_is_str(nm) || !val) {+ return false;+ }+ char vbuf[CBM_SZ_64];+ const char *v = NULL;+ if (yyjson_mut_is_str(val)) {+ v = yyjson_mut_get_str(val);+ } else if (yyjson_mut_is_real(val)) {+ snprintf(vbuf, sizeof(vbuf), "%.17g", yyjson_mut_get_real(val));+ v = vbuf;+ } else if (yyjson_mut_is_bool(val)) {+ v = yyjson_mut_get_bool(val) ? "true" : "false";+ }+ bool as_string = yyjson_mut_is_str(ty) && strcmp(yyjson_mut_get_str(ty), "string") == 0;+ return v && cbm_helm_values_set(doc, root, yyjson_mut_get_str(nm), v, as_string);+}++/* A `set` block's attributes as an object; NULL when one is no literal. */+static yyjson_mut_val *tf_set_block(const tf_t *t, yyjson_mut_doc *doc, TSNode block) {+ yyjson_mut_val *entry = yyjson_mut_obj(doc);+ for (uint32_t j = 0; entry && j < ts_node_named_child_count(block); j++) {+ TSNode sb = ts_node_named_child(block, j);+ if (!tf_type(sb, "body")) {+ continue;+ }+ for (uint32_t k = 0; k < ts_node_named_child_count(sb); k++) {+ TSNode at = ts_node_named_child(sb, k);+ if (!tf_type(at, "attribute") || ts_node_named_child_count(at) < PAIR_LEN) {+ continue;+ }+ TSNode key = ts_node_named_child(at, 0);+ uint32_t b = ts_node_start_byte(key);+ yyjson_mut_val *v = tf_json(t, doc, ts_node_named_child(at, SKIP_ONE));+ if (!v) {+ return NULL;+ }+ yyjson_mut_obj_add(entry,+ yyjson_mut_strncpy(doc, t->src + b, ts_node_end_byte(key) - b), v);+ }+ }+ return entry;+}++/* The values a helm_release body gives its chart -- `values` items+ * coalesced in order, then each `set` -- as JSON (cbm_alloc); NULL when a+ * part is no literal. set_sensitive is never read. */+static char *tf_release_values(const tf_t *t, TSNode body, const char ***files, int *nfiles) {+ yyjson_mut_doc *doc = yyjson_mut_doc_new(cbm_json_writer_allocator());+ yyjson_mut_val *root = doc ? yyjson_mut_obj(doc) : NULL;+ bool ok = root != NULL;+ for (int pass = 0; ok && pass < PAIR_LEN; pass++) {+ for (uint32_t i = 0; ok && i < ts_node_named_child_count(body); i++) {+ TSNode a = ts_node_named_child(body, i);+ TSNode key = ts_node_named_child(a, 0);+ uint32_t kb = ts_node_is_null(key) ? 0 : ts_node_start_byte(key);+ size_t kl = ts_node_is_null(key) ? 0 : ts_node_end_byte(key) - kb;+ bool is_set = kl == strlen("set") && strncmp(t->src + kb, "set", kl) == 0;+ bool is_values = kl == strlen("values") && strncmp(t->src + kb, "values", kl) == 0;+ /* set_list values are not read: the release's values are partial */+ if (kl == strlen("set_list") && strncmp(t->src + kb, "set_list", kl) == 0) {+ ok = false;+ break;+ }+ if (pass == 0 && is_values && tf_type(a, "attribute")) {+ TSNode list = tf_unwrap(ts_node_named_child(a, SKIP_ONE));+ ok = tf_type(list, "tuple");+ for (uint32_t j = 0; ok && j < ts_node_named_child_count(list); j++) {+ TSNode it = ts_node_named_child(list, j);+ if (tf_type(it, "tuple_start") || tf_type(it, "tuple_end")) {+ continue;+ }+ yyjson_mut_val *v = tf_values_item(t, doc, it, t->arena, files, nfiles);+ ok = v && yyjson_mut_is_obj(v);+ root = ok ? cbm_helm_values_coalesce(doc, root, v) : root;+ }+ } else if (pass == SKIP_ONE && is_set && tf_type(a, "block")) {+ yyjson_mut_val *entry = tf_set_block(t, doc, a);+ ok = entry && tf_set_entry(doc, root, entry);+ } else if (pass == SKIP_ONE && is_set && tf_type(a, "attribute")) {+ /* provider v3: set = [{ name, value, type }, ...] */+ yyjson_mut_val *list = tf_json(t, doc, ts_node_named_child(a, SKIP_ONE));+ ok = yyjson_mut_is_arr(list);+ size_t idx, max;+ yyjson_mut_val *entry;+ yyjson_mut_arr_foreach(list, idx, max, entry) {+ ok = ok && tf_set_entry(doc, root, entry);+ }+ }+ }+ }+ char *out = NULL;+ if (ok) {+ size_t len = 0;+ out = yyjson_mut_val_write_opts(root, 0, cbm_json_writer_allocator(), &len, NULL);+ }+ if (doc) {+ yyjson_mut_doc_free(doc);+ }+ return out;+}++static void tf_release_push(tf_t *t, int64_t src, int64_t chart, TSNode body) {+ cbm_pipeline_ctx_t *ctx = t->ctx;+ if (ctx->tf_release_n == ctx->tf_release_cap) {+ int cap = ctx->tf_release_cap ? ctx->tf_release_cap * PAIR_LEN : CBM_SZ_16;+ cbm_tf_release_t *g =+ cbm_realloc(CBM_MEM_CLASS_OTHER, ctx->tf_releases, (size_t)cap * sizeof(*g));+ if (!g) {+ return;+ }+ ctx->tf_releases = g;+ ctx->tf_release_cap = cap;+ }+ const char **files = NULL;+ int nfiles = 0;+ ctx->tf_releases[ctx->tf_release_n++] =+ (cbm_tf_release_t){src, chart, tf_release_values(t, body, &files, &nfiles)};+ /* the values files it reads, like a kustomization's valuesFile: an edit of+ * one alone renders the release again (pipeline_incremental.c) */+ for (int i = 0; i < nfiles; i++) {+ const char *mqn = cbm_fqn_module(t->arena, ctx->project_name, files[i]);+ const cbm_gbuf_node_t *mod = mqn ? cbm_gbuf_find_by_qn(ctx->gbuf, mqn) : NULL;+ if (mod && mod->id != src) {+ cbm_gbuf_insert_edge(ctx->gbuf, src, mod->id, "IMPORTS", "{\"local_name\":\"values\"}");+ t->edges++;+ }+ }+}+static void tf_helm_release(tf_t *t, TSNode block, const char *name) {TSNode body = {0};for (uint32_t i = 0; i < ts_node_named_child_count(block); i++) {@@ -320,6 +718,7 @@ static void tf_helm_release(tf_t *t, TSNode block, const char *name) {external ? ",\"external\":true" : "", (int)ts_node_start_point(block).row + SKIP_ONE);cbm_gbuf_insert_edge(t->ctx->gbuf, src, tgt, "DEPLOYS", props);t->edges++;+ tf_release_push(t, src, tgt, body);}/* The text of a string_lit label: "helm_release" -> helm_release. */diff --git a/src/pipeline/pipeline_incremental.c b/src/pipeline/pipeline_incremental.cindex 99df053e4..bb97c361d 100644--- a/src/pipeline/pipeline_incremental.c+++ b/src/pipeline/pipeline_incremental.c@@ -2456,8 +2456,9 @@ static bool closure_dir_has_compose(const char *repo_path, const char *rel, consreturn found;}-/* The nearest directory at or above `rel`'s that holds a Chart.yaml, into out- * ("" for the repository root); false when none does. */+/* The nearest directory at or above `rel`'s that holds a Chart.yaml, or is a+ * werf `.helm` chart, into out ("" for the repository root); false when none+ * is. */static bool closure_chart_dir_of(const char *repo_path, const char *rel, char *out, size_t sz) {snprintf(out, sz, "%s", rel);char *cut = strrchr(out, '/');@@ -2475,6 +2476,9 @@ static bool closure_chart_dir_of(const char *repo_path, const char *rel, char *oreturn true;}}+ if (out[0] && cbm_werf_helm_dir(repo_path, out)) {+ return true;+ }if (!out[0]) {return false;}@@ -2482,6 +2486,33 @@ static bool closure_chart_dir_of(const char *repo_path, const char *rel, char *o}}+/* Is `rel` a file a release reads as values (an IMPORTS {local_name:+ * valuesFile | values} edge reaches its node)? */+static bool closure_release_values(cbm_store_t *store, const char *project, const char *rel) {+ cbm_node_t *nodes = NULL;+ int count = 0;+ if (cbm_store_find_nodes_by_file(store, project, rel, &nodes, &count) != CBM_STORE_OK) {+ return false;+ }+ bool hit = false;+ for (int i = 0; i < count && !hit; i++) {+ cbm_edge_t *edges = NULL;+ int ne = 0;+ if (cbm_store_find_edges_by_target_type(store, nodes[i].id, "IMPORTS", &edges, &ne) !=+ CBM_STORE_OK) {+ continue;+ }+ for (int j = 0; j < ne && !hit; j++) {+ const char *p = edges[j].properties_json;+ hit = p && (strstr(p, "\"local_name\":\"valuesFile\"") ||+ strstr(p, "\"local_name\":\"values\""));+ }+ cbm_store_free_edges(edges, ne);+ }+ cbm_store_free_nodes(nodes, count);+ return hit;+}+/* Kubernetes inputs reach past their own file (pass_k8s.c): a kustomization* decides which manifests deploy together and in which namespace, a* Chart.yaml links other charts, and a manifest's Services select workloads@@ -2498,7 +2529,9 @@ static const char *closure_k8s_decline(cbm_store_t *store, const char *project,if (cbm_is_kustomize_file(base) || strcmp(base, "Kustomization") == 0) {return "k8s_bundle_input_changed";}- if (strcmp(base, "Chart.yaml") == 0 || strcmp(base, "Chart.yml") == 0) {+ /* A werf.yaml names the chart of the `.helm` dir beside it. */+ if (strcmp(base, "Chart.yaml") == 0 || strcmp(base, "Chart.yml") == 0 ||+ strcmp(base, "werf.yaml") == 0 || strcmp(base, "werf.yml") == 0) {return "helm_chart_changed";}/* A chart's values file CONFIGURES it and its templates/ are what it@@ -2518,6 +2551,12 @@ static const char *closure_k8s_decline(cbm_store_t *store, const char *project,if (strcmp(base, ".env") == 0 && closure_dir_has_compose(repo_path, rel, base)) {return "compose_env_changed";}+ /* A release's values file -- a kustomization's valuesFile, a Terraform+ * helm_release's file(...) -- feeds the images the release renders,+ * which a repair of the values file alone does not redraw. */+ if (closure_release_values(store, project, rel)) {+ return "helm_release_values_changed";+ }cbm_node_t *nodes = NULL;int count = 0;if (cbm_store_find_nodes_by_file(store, project, rel, &nodes, &count) != CBM_STORE_OK) {diff --git a/src/pipeline/pipeline_internal.h b/src/pipeline/pipeline_internal.hindex fbae8044f..553aa19d9 100644--- a/src/pipeline/pipeline_internal.h+++ b/src/pipeline/pipeline_internal.h@@ -380,6 +380,16 @@ typedef struct {int reader_count;} cbm_envjoin_base_t;+/* A Terraform helm_release (pass_terraform.c): the chart it DEPLOYS and its+ * values -- `values = [...]` coalesced in order, then `set` -- as JSON; NULL+ * when a part is not a literal (an interpolation, a variable). pass_k8s.c+ * renders the chart's images with them. */+typedef struct cbm_tf_release {+ int64_t src; /* the resource.helm_release node */+ int64_t chart; /* the Chart node */+ char *values; /* owned (cbm_free); NULL: unknown */+} cbm_tf_release_t;+/* Shared context passed to each pass function.* Derived from cbm_pipeline_t fields during run. */typedef struct {@@ -486,6 +496,12 @@ typedef struct {const struct cbm_doclink_scope *doc_link_base;int doc_link_base_count;bool doc_links_failed;++ /* The run's Terraform helm_releases (pass_terraform.c fills them, the K8s+ * pass reads and frees them right after). */+ cbm_tf_release_t *tf_releases;+ int tf_release_n;+ int tf_release_cap;} cbm_pipeline_ctx_t;/* Origin-aware LSP returns only success/failure. Never retain partial output@@ -1060,6 +1076,9 @@ bool cbm_is_k8s_manifest(const char *name, const char *content);/* A Helm values file name: values.yaml / .yml, values-<x>.yaml / .yml* (pass_k8s.c; beside Chart.yaml it CONFIGURES the chart). */bool cbm_helm_values_name(const char *base);+/* Is `dir` (repository relative) a werf chart: a `.helm` directory without a+ * Chart.yaml whose parent holds werf.yaml (pass_k8s.c)? */+bool cbm_werf_helm_dir(const char *repo_path, const char *dir);/* Secret detection */bool cbm_is_secret_binding(const char *key, const char *value);@@ -1259,6 +1278,7 @@ typedef struct {const char *via; /* "skaffold" / "compose" */const char *image; /* the reference, variables expanded */const char *dockerfile; /* repository path */+ const char *build_args; /* compose build.args as a JSON object; NULL: none */int line;} cbm_build_site_t;typedef void (*cbm_build_site_fn)(const cbm_build_site_t *site, void *ud);@@ -1269,10 +1289,17 @@ typedef void (*cbm_build_site_fn)(const cbm_build_site_t *site, void *ud);* depends_on and links list, and the names of the environment variables its* environment sets (map keys / list items' names -- never a value), with* their 1-based lines and the service name each value addresses (a bare- * name, `name:port`, a URL's host; NULL: none -- cbm_env_address). */+ * name, `name:port`, a URL's host; NULL: none -- cbm_env_address).+ * image_default_of: the variables whose inline default (${X:-d}) named the+ * image; image_override_of: those whose default the project's .env replaced+ * (JSON arrays, NULL: none), and default_image the image those defaults+ * name. */typedef struct {const char *name;const char *image;+ const char *image_default_of;+ const char *image_override_of;+ const char *default_image;const char *dockerfile;const char **deps;int ndeps;@@ -1340,6 +1367,12 @@ bool cbm_repo_rel_join(const char *dir, const char *v, char *out, size_t sz);* for an official image; registry "unknown" when the reference names no* host -- none is invented), made when new; 0 for scratch or no image. */int64_t cbm_pipeline_image_node(cbm_pipeline_ctx_t *ctx, const char *ref);+/* Does `ref` follow the image reference grammar (distribution/reference):+ * [host[:port]/]path[:tag][@algo:hex], path components lowercase alphanumerics+ * joined by `.`, `_`, `__` or dashes, a tag of word characters, `.` and `-`+ * (128 at most)? A value rendered from a template is checked before it names+ * an Image (pass_docker.c). */+bool cbm_image_ref_valid(const char *ref);/* A chart repository URL as an identity (pass_k8s.c): `url` trimmed, its* scheme and host lower-cased, trailing `/` and `.git` dropped. False for no@@ -1730,7 +1763,8 @@ int cbm_delta_drop_edges_from_label(cbm_store_t *store, const char *project, conconst char *label);/* The edges that keep a file-less shared node alive. */#define SH_PROCESS_EDGES ((const char *const[]){"SPAWNS", NULL})-#define DK_IMAGE_EDGES ((const char *const[]){"DEPENDS_ON", "USAGE", NULL})+/* An Image a release DEPLOYS (pass_k8s.c release images) may have no other edge. */+#define DK_IMAGE_EDGES ((const char *const[]){"DEPENDS_ON", "USAGE", "DEPLOYS", NULL})/* Pre-seed proxy nodes with their REAL database ids and move the gbuf id* watermark above MAX(id); returns that max id, or -1 on failure. */int64_t cbm_delta_preseed(cbm_store_t *store, const char *project, cbm_gbuf_t *gbuf);diff --git a/tests/test_grammar_probe_f.c b/tests/test_grammar_probe_f.cindex cebd5275b..f7405e959 100644--- a/tests/test_grammar_probe_f.c+++ b/tests/test_grammar_probe_f.c@@ -4445,6 +4445,7 @@ static char *gpf_chart_edges(const GpfFile *files, int nfiles) {"SELECT coalesce(group_concat(x, char(10)), '') FROM (SELECT CASE WHEN ""s.label='File' THEN s.file_path ELSE s.name END || ' -> ' || t.label || ':' || ""t.name || ' (' || e.type || coalesce(' ' || json_extract(e.properties,'$.ref'), '') "+ "|| coalesce(' ' || json_extract(e.properties,'$.phase'), '') ""|| ')' AS x FROM edges e JOIN nodes s ON s.id=e.source_id JOIN nodes t ON ""t.id=e.target_id WHERE e.project=?1 AND ((s.label='Chart' AND e.type='DEPLOYS') OR ""(t.label='Chart' AND e.type='CONFIGURES')) ORDER BY x)";@@ -4462,8 +4463,8 @@ static char *gpf_chart_edges(const GpfFile *files, int nfiles) {/* A chart deploys what its templates render: Chart -DEPLOYS {via: chart}->* each object of its templates/ (a subchart's objects are the subchart's),- * and each Image those objects name literally ({ref: image}) -- a templated- * image names none, and no values default is read. Its values files+ * and each Image those objects use ({ref: image}) -- a templated one rendered+ * from values.yaml (`nginx`: host-less, kept as written). Its values files* (values.yaml, values-*.yaml beside Chart.yaml) CONFIGURE it; a values file* elsewhere (ci/) does not. */TEST(probe_helm_chart_deploys_its_objects) {@@ -4492,6 +4493,7 @@ TEST(probe_helm_chart_deploys_its_objects) {"db -> Image:ghcr.io/acme/db (DEPLOYS image)\n""db -> Resource:StatefulSet/db (DEPLOYS)\n""web -> Image:ghcr.io/acme/sidecar (DEPLOYS image)\n"+ "web -> Image:nginx (DEPLOYS image)\n""web -> Resource:Deployment/web (DEPLOYS)\n""web -> Resource:Service/web (DEPLOYS)";if (!got || strcmp(got, want) != 0) {@@ -4503,6 +4505,267 @@ TEST(probe_helm_chart_deploys_its_objects) {PASS();}+/* A chart also deploys the CRDs of its crds/ ({phase: crds}), which Helm+ * installs before its templates. werf deploys the `.helm` dir beside its+ * werf.yaml as a chart without Chart.yaml, named after the werf project+ * (templated werf.yaml lines before it are skipped); a `.helm` with its own+ * Chart.yaml stays that chart, and a werf.yaml without `.helm` makes none. */+TEST(probe_helm_chart_crds_and_werf_chart) {+ static const GpfFile files[] = {+ {"charts/op/Chart.yaml", "apiVersion: v2\nname: op\nversion: 1.0.0\n"},+ {"charts/op/crds/widget.yaml",+ "apiVersion: apiextensions.k8s.io/v1\nkind: CustomResourceDefinition\nmetadata:\n"+ " name: widgets.acme.io\nspec:\n group: acme.io\n names:\n kind: Widget\n"+ " plural: widgets\n scope: Namespaced\n"},+ {"charts/op/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: op\n"},+ {"site/werf.yaml", "{{- $_ := set . \"Env\" (.Env | default \"prod\") }}\n\n"+ "project: site-web\nconfigVersion: 1\n---\nimage: web\nfrom: nginx\n"},+ {"site/.helm/values.yaml", "replicas: 1\n"},+ {"site/.helm/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: site\nspec:\n"+ " replicas: {{ .Values.replicas }}\n"},+ {"plain/werf.yaml", "project: plain\nconfigVersion: 1\n"},+ {"own/werf.yaml", "project: own-werf\nconfigVersion: 1\n"},+ {"own/.helm/Chart.yaml", "apiVersion: v2\nname: own\nversion: 0.1.0\n"},+ {"own/.helm/templates/cm.yaml",+ "apiVersion: v1\nkind: ConfigMap\nmetadata:\n name: own\n"}};+ char *got = gpf_chart_edges(files, 10);+ static const char want[] =+ "op -> Resource:CustomResourceDefinition/widgets.acme.io (DEPLOYS crds)\n"+ "op -> Resource:Deployment/op (DEPLOYS)\n"+ "own -> Resource:ConfigMap/own (DEPLOYS)\n"+ "site-web -> Resource:Deployment/site (DEPLOYS)\n"+ "site/.helm/values.yaml -> Chart:site-web (CONFIGURES)";+ if (!got || strcmp(got, want) != 0) {+ fprintf(stderr, "chart edges got:\n%s\nwant:\n%s\n", got ? got : "(null)", want);+ free(got);+ FAIL("crds/ and werf chart edge set");+ }+ free(got);+ PASS();+}++/* Every edge into an Image (or out of one into an Image), one line each:+ * `source -> Image:name TYPE image=.. [via=..] [ref=..] [default_of=..]+ * [override_of=..] [inferred=..] [values_key=..]`, sorted. */+static char *gpf_image_edges(const GpfFile *files, int nfiles) {+ GpfProj lp;+ cbm_store_t *store = gpf_index_files(&lp, files, nfiles);+ char *out = NULL;+ if (store) {+ sqlite3_stmt *st = NULL;+ const char *sql =+ "SELECT coalesce(group_concat(x, char(10)), '') FROM (SELECT s.label || ':' || s.name "+ "|| ' -> Image:' || t.name || ' ' || e.type || ' image=' || "+ "coalesce(json_extract(e.properties,'$.image'),'-') || "+ "coalesce(' via=' || json_extract(e.properties,'$.via'), '') || "+ "coalesce(' ref=' || json_extract(e.properties,'$.ref'), '') || "+ "coalesce(' default_of=' || json_extract(e.properties,'$.default_of'), '') || "+ "coalesce(' override_of=' || json_extract(e.properties,'$.override_of'), '') || "+ "coalesce(' inferred=' || json_extract(e.properties,'$.inferred'), '') || "+ "coalesce(' values_key=' || json_extract(e.properties,'$.values_key'), '') AS x "+ "FROM edges e JOIN nodes s ON s.id=e.source_id JOIN nodes t ON t.id=e.target_id "+ "WHERE e.project=?1 AND t.label='Image' ORDER BY x)";+ if (sqlite3_prepare_v2(cbm_store_get_db(store), sql, -1, &st, NULL) == SQLITE_OK) {+ sqlite3_bind_text(st, 1, lp.project, -1, SQLITE_STATIC);+ if (sqlite3_step(st) == SQLITE_ROW) {+ out = strdup((const char *)sqlite3_column_text(st, 0));+ }+ }+ sqlite3_finalize(st);+ }+ gpf_cleanup(&lp, store);+ return out;+}++static bool gpf_expect_image_edges(const GpfFile *files, int n, const char *want) {+ char *got = gpf_image_edges(files, n);+ bool ok = got && strcmp(got, want) == 0;+ if (!ok) {+ fprintf(stderr, "image edges got:\n%s\nwant:\n%s\n", got ? got : "(null)", want);+ }+ free(got);+ return ok;+}++/* An image a default value names keeps its Image, its edge marked+ * default_of with the ARGs / variables whose default supplied it (an ARG+ * chain names each); a literal FROM is unmarked. A build's arguments (compose+ * build.args, docker build --build-arg) make the Image it builds DEPEND_ON+ * the base they choose {override_of}; compose's .env replacing an inline+ * default is the effective edge's override_of, the default's image kept as+ * {ref: image_default} -- one the service does not run. */+TEST(probe_docker_default_images_marked_and_overrides) {+ static const GpfFile files[] = {+ {"src/web/Dockerfile", "ARG GO=1.22\nARG BASE=golang:${GO}\nFROM ${BASE} AS build\n"+ "RUN go build -o /app .\nFROM alpine:3.20\n"+ "COPY --from=build /app /app\n"},+ {"src/api/Dockerfile", "ARG PY=3.12\nFROM python:${PY}-slim\n"},+ {".env", "REG=ghcr.io/acme\nAPI_IMG=ghcr.io/acme/api-custom\n"},+ {"compose.yaml", "services:\n web:\n image: ${REG}/web:${TAG:-dev}\n build:\n"+ " context: ./src/web\n args:\n GO: \"1.23\"\n"+ " api:\n image: ${API_IMG:-ghcr.io/acme/api}\n build: ./src/api\n"},+ {"scripts/build.sh", "#!/bin/sh\nIMAGE=${IMAGE:-ghcr.io/acme/api-ci}\n"+ "docker build --build-arg PY=3.13 -t \"$IMAGE:1\" src/api\n"}};+ static const char want[] =+ "Image:ghcr.io/acme/api-ci -> Image:python DEPENDS_ON image=python:3.13-slim via=from "+ "override_of=[\"PY\"]\n"+ "Image:ghcr.io/acme/web -> Image:golang DEPENDS_ON image=golang:1.23 via=from "+ "default_of=[\"BASE\"] override_of=[\"GO\"]\n"+ "Module:src/api/Dockerfile -> Image:python DEPENDS_ON image=python:3.12-slim via=from "+ "default_of=[\"PY\"]\n"+ "Module:src/web/Dockerfile -> Image:alpine DEPENDS_ON image=alpine:3.20 via=from\n"+ "Module:src/web/Dockerfile -> Image:golang DEPENDS_ON image=golang:1.22 via=from "+ "default_of=[\"GO\",\"BASE\"]\n"+ "Resource:Service/api -> Image:ghcr.io/acme/api USAGE image=ghcr.io/acme/api "+ "ref=image_default default_of=[\"API_IMG\"]\n"+ "Resource:Service/api -> Image:ghcr.io/acme/api-custom USAGE image=ghcr.io/acme/api-custom "+ "ref=image override_of=[\"API_IMG\"]\n"+ "Resource:Service/web -> Image:ghcr.io/acme/web USAGE image=ghcr.io/acme/web:dev "+ "ref=image default_of=[\"TAG\"]";+ if (!gpf_expect_image_edges(files, 5, want)) {+ FAIL("default-valued images and their in-repo overrides");+ }+ PASS();+}++/* The chart a Helm template renders (helm_template.c): the container image+ * from the chart family's defaults -- an include helper (bitnami+ * common.images.image, a dict argument, .Chart.AppVersion), a `with`+ * binding, the taken branch of an if / else, a subchart under its alias with+ * the parent's values and global. The object USES it {default_of: the values+ * keys read}; the chart DEPLOYS it. A value that does not render -- a+ * .Release field, lookup, a missing define, a field of a missing map -- names+ * no Image. */+TEST(probe_helm_template_images_render_with_defaults) {+ static const GpfFile files[] = {+ {"charts/app/Chart.yaml",+ "apiVersion: v2\nname: app\nversion: 1.2.3\nappVersion: \"2.0.1\"\ndependencies:\n"+ " - name: db\n version: 0.1.0\n alias: database\n"},+ {"charts/app/values.yaml",+ "image:\n registry: ghcr.io\n repository: acme/app\n tag: \"\"\n digest: \"\"\n"+ "sidecar:\n image: { repository: docker.io/library/busybox, tag: 1.36 }\nglobal: {}\n"+ "database:\n image:\n tag: \"17\"\n"},+ {"charts/app/templates/_helpers.tpl",+ "{{- define \"common.images.image\" -}}\n"+ "{{- $registryName := default .imageRoot.registry ((.global).imageRegistry) -}}\n"+ "{{- $termination := .imageRoot.tag | toString -}}\n"+ "{{- if not .imageRoot.tag }}\n {{- if .chart }}\n"+ " {{- $termination = .chart.AppVersion | toString -}}\n {{- end -}}\n{{- end -}}\n"+ "{{- if $registryName }}\n"+ "{{- printf \"%s/%s:%s\" $registryName .imageRoot.repository $termination -}}\n"+ "{{- else -}}\n{{- printf \"%s:%s\" .imageRoot.repository $termination -}}\n"+ "{{- end -}}\n{{- end -}}\n"},+ {"charts/app/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: app\nspec:\n template:\n"+ " spec:\n containers:\n - name: app\n image: {{ include "+ "\"common.images.image\" (dict \"imageRoot\" .Values.image \"global\" .Values.global "+ "\"chart\" .Chart) }}\n - name: side\n {{- with .Values.sidecar.image }}\n"+ " image: \"{{ .repository }}:{{ .tag }}\"\n {{- end }}\n"+ " - name: rel\n image: \"ghcr.io/acme/{{ .Release.Name }}:1\"\n"+ " - name: miss\n image: {{ include \"nope\" . }}\n"+ " - name: deep\n image: \"{{ .Values.absent.repository }}\"\n"},+ {"charts/app/charts/db/Chart.yaml",+ "apiVersion: v2\nname: db\nversion: 0.1.0\nappVersion: \"16.4\"\n"},+ {"charts/app/charts/db/values.yaml",+ "image:\n repository: bitnami/postgresql\n tag: \"\"\n digest: \"\"\n"},+ {"charts/app/charts/db/templates/sts.yaml",+ "apiVersion: apps/v1\nkind: StatefulSet\nmetadata:\n name: db\nspec:\n template:\n"+ " spec:\n containers:\n - name: db\n {{- if .Values.image.digest }}\n"+ " image: \"{{ .Values.global.imageRegistry | default \"docker.io\" }}/"+ "{{ .Values.image.repository }}@{{ .Values.image.digest }}\"\n {{- else }}\n"+ " image: \"{{ .Values.global.imageRegistry | default \"docker.io\" }}/"+ "{{ .Values.image.repository }}:{{ .Values.image.tag | default .Chart.AppVersion }}\"\n"+ " {{- end }}\n"}};+ static const char want[] =+ "Chart:app -> Image:docker.io/library/busybox DEPLOYS image=- via=chart ref=image "+ "default_of=[\"sidecar.image.repository\",\"sidecar.image.tag\"]\n"+ "Chart:app -> Image:ghcr.io/acme/app DEPLOYS image=- via=chart ref=image "+ "default_of=[\"image.registry\",\"global.imageRegistry\",\"image.tag\","+ "\"image.repository\"]\n"+ "Chart:db -> Image:docker.io/bitnami/postgresql DEPLOYS image=- via=chart ref=image "+ "default_of=[\"global.imageRegistry\",\"image.repository\",\"image.tag\"]\n"+ "Resource:Deployment/app -> Image:docker.io/library/busybox USAGE "+ "image=docker.io/library/busybox:1.36 ref=image "+ "default_of=[\"sidecar.image.repository\",\"sidecar.image.tag\"]\n"+ "Resource:Deployment/app -> Image:ghcr.io/acme/app USAGE image=ghcr.io/acme/app:2.0.1 "+ "ref=image default_of=[\"image.registry\",\"global.imageRegistry\",\"image.tag\","+ "\"image.repository\"]\n"+ "Resource:StatefulSet/db -> Image:docker.io/bitnami/postgresql USAGE "+ "image=docker.io/bitnami/postgresql:17 ref=image "+ "default_of=[\"global.imageRegistry\",\"image.repository\",\"image.tag\"]";+ if (!gpf_expect_image_edges(files, 7, want)) {+ FAIL("Helm template images rendered with the chart family's defaults");+ }+ PASS();+}++/* A release renders its chart with its values over the defaults: of a chart+ * in the repository each image that differs is the release's own {via,+ * override_of} -- a Flux HelmRelease's spec.values (a Git source), a+ * kustomize helmCharts entry's valuesFile + valuesInline (chartHome charts/),+ * a Terraform helm_release's values + set. Of an external chart the values+ * name images by convention -- `repository` (+ tag / registry) naming a+ * registry host -- {inferred: values}; a host-less repository names none. */+TEST(probe_helm_release_images) {+ static const GpfFile files[] = {+ {"charts/app/Chart.yaml", "apiVersion: v2\nname: app\nversion: 1.0.0\n"},+ {"charts/app/values.yaml", "image:\n repository: ghcr.io/acme/app\n tag: \"1.0\"\n"},+ {"charts/app/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: app\nspec:\n template:\n"+ " spec:\n containers:\n - name: app\n"+ " image: \"{{ .Values.image.repository }}:{{ .Values.image.tag }}\"\n"},+ {"flux/app.yaml",+ "apiVersion: helm.toolkit.fluxcd.io/v2\nkind: HelmRelease\nmetadata:\n name: app\nspec:\n"+ " chart:\n spec:\n chart: ./charts/app\n sourceRef:\n"+ " kind: GitRepository\n name: repo\n values:\n image:\n"+ " tag: \"9.9\"\n---\n"+ "apiVersion: helm.toolkit.fluxcd.io/v2\nkind: HelmRelease\nmetadata:\n name: sonarr\n"+ "spec:\n chart:\n spec:\n chart: app-template\n sourceRef:\n"+ " kind: HelmRepository\n name: bjw-s\n values:\n controllers:\n"+ " main:\n containers:\n main:\n image:\n"+ " repository: ghcr.io/home-operations/sonarr\n tag: 4.0.15\n"+ " side:\n image:\n repository: busybox\n"+ " tag: \"1.36\"\n"},+ {"kz/kustomization.yaml",+ "apiVersion: kustomize.config.k8s.io/v1beta1\nkind: Kustomization\nhelmCharts:\n"+ " - name: app\n releaseName: kapp\n valuesFile: values-prod.yaml\n"+ " valuesInline:\n image:\n tag: \"5.5\"\n"},+ {"kz/values-prod.yaml", "image:\n repository: quay.io/acme/app\n tag: \"4.4\"\n"},+ {"kz/charts/app/Chart.yaml", "apiVersion: v2\nname: app\nversion: 1.0.0\n"},+ {"kz/charts/app/values.yaml", "image:\n repository: ghcr.io/acme/app\n tag: \"1.0\"\n"},+ {"kz/charts/app/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: kapp\nspec:\n template:\n"+ " spec:\n containers:\n - name: app\n"+ " image: \"{{ .Values.image.repository }}:{{ .Values.image.tag }}\"\n"},+ {"tf/main.tf", "resource \"helm_release\" \"app\" {\n name = \"app\"\n"+ " chart = \"../charts/app\"\n set {\n name = \"image.tag\"\n"+ " value = \"7.7\"\n }\n}\n"}};+ static const char want[] =+ "Chart:app -> Image:ghcr.io/acme/app DEPLOYS image=- via=chart ref=image "+ "default_of=[\"image.repository\",\"image.tag\"]\n"+ "Chart:app -> Image:ghcr.io/acme/app DEPLOYS image=- via=chart ref=image "+ "default_of=[\"image.repository\",\"image.tag\"]\n"+ "Class:resource.helm_release.app -> Image:ghcr.io/acme/app DEPLOYS "+ "image=ghcr.io/acme/app:7.7 via=terraform ref=image override_of=[\"image.tag\"]\n"+ "Resource:Deployment/app -> Image:ghcr.io/acme/app USAGE image=ghcr.io/acme/app:1.0 "+ "ref=image default_of=[\"image.repository\",\"image.tag\"]\n"+ "Resource:Deployment/kapp -> Image:ghcr.io/acme/app USAGE image=ghcr.io/acme/app:1.0 "+ "ref=image default_of=[\"image.repository\",\"image.tag\"]\n"+ "Resource:HelmRelease/app -> Image:ghcr.io/acme/app DEPLOYS image=ghcr.io/acme/app:9.9 "+ "via=helmrelease ref=image override_of=[\"image.tag\"]\n"+ "Resource:HelmRelease/sonarr -> Image:ghcr.io/home-operations/sonarr DEPLOYS "+ "image=ghcr.io/home-operations/sonarr:4.0.15 via=helmrelease ref=image inferred=values "+ "values_key=controllers.main.containers.main.image\n"+ "Resource:Kustomization -> Image:quay.io/acme/app DEPLOYS image=quay.io/acme/app:5.5 "+ "via=helmcharts ref=image override_of=[\"image.repository\",\"image.tag\"]";+ if (!gpf_expect_image_edges(files, 10, want)) {+ FAIL("release images: local renders and the external values convention");+ }+ PASS();+}+/* A template's `include "name"` calls the define of that name in its chart* family -- the chart and its subcharts share one template namespace -- never* a same-named define of an unrelated chart; a define may also be written in@@ -6313,6 +6576,10 @@ SUITE(grammar_probe_f) {RUN_TEST(probe_terraform_helm_release_deploys_its_chart);RUN_TEST(probe_helm_templated_objects_are_resources);RUN_TEST(probe_helm_chart_deploys_its_objects);+ RUN_TEST(probe_helm_chart_crds_and_werf_chart);+ RUN_TEST(probe_docker_default_images_marked_and_overrides);+ RUN_TEST(probe_helm_template_images_render_with_defaults);+ RUN_TEST(probe_helm_release_images);RUN_TEST(probe_helm_include_resolves_in_the_chart_family);RUN_TEST(probe_k8s_selector_stays_in_its_directory);RUN_TEST(probe_k8s_selector_within_kustomize_build);diff --git a/tests/test_pipeline.c b/tests/test_pipeline.cindex b52513ace..079df09da 100644--- a/tests/test_pipeline.c+++ b/tests/test_pipeline.c@@ -15,6 +15,7 @@#include "pipeline/lsp_surface.h"#include "pipeline/pass_lsp_cross.h"#include "pipeline/pipeline_internal.h"+#include "pipeline/helm_template.h"#include "pipeline/artifact.h"#include "store/store.h"#include "semantic/semantic.h"@@ -4205,6 +4206,135 @@ TEST(incremental_helm_values_edit_keeps_chart_edge) {PASS();}+/* A werf `.helm` dir is a chart without Chart.yaml (pass_k8s.c): its values+ * file CONFIGURES the werf Chart, an edge a closure repair of the values file+ * alone does not hold, so the edit rebuilds, like one beside a Chart.yaml. */+TEST(incremental_werf_values_edit_keeps_chart_edge) {+ char tmp[256];+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_werfchart_XXXXXX");+ if (!cbm_mkdtemp(tmp)) {+ FAIL("tmpdir");+ }+ write_temp_file(tmp, "werf.yaml", "project: site\nconfigVersion: 1\n");+ write_temp_file(tmp, ".helm/values.yaml", "replicas: 1\n");+ write_temp_file(tmp, ".helm/templates/svc.yaml",+ "apiVersion: v1\nkind: Service\nmetadata:\n name: web\n");+ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/werfchart.db", tmp);+ static const char edge[] =+ "SELECT COUNT(*) FROM edges e JOIN nodes s ON s.id=e.source_id JOIN nodes t ON "+ "t.id=e.target_id WHERE e.type='CONFIGURES' AND s.file_path='.helm/values.yaml' AND "+ "t.label='Chart' AND t.name='site'";+ int before = k8s_inc_index(tmp, db_path) == 0 ? k8s_inc_count(db_path, edge) : -1;+ write_temp_file(tmp, ".helm/values.yaml", "replicas: 3\n");+ int after = k8s_inc_index(tmp, db_path) == 0 ? k8s_inc_count(db_path, edge) : -1;+ cbm_incremental_route_t route = cbm_pipeline_incremental_test_last_route();+ th_rmtree(tmp);+ ASSERT_EQ(before, 1);+ ASSERT_EQ(after, 1);+ ASSERT_EQ(route, CBM_INCREMENTAL_ROUTE_FORCED_FULL);+ PASS();+}++/* A kustomization's helmCharts valuesFile (an IMPORTS {local_name:+ * valuesFile} target) feeds the image the release renders: the values file+ * edited alone rebuilds, and the release's image follows the edit. */+TEST(incremental_release_values_edit_rebuilds) {+ char tmp[256];+ snprintf(tmp, sizeof(tmp), "/tmp/cbm_relvalues_XXXXXX");+ if (!cbm_mkdtemp(tmp)) {+ FAIL("tmpdir");+ }+ write_temp_file(tmp, "kz/kustomization.yaml",+ "apiVersion: kustomize.config.k8s.io/v1beta1\nkind: Kustomization\n"+ "helmCharts:\n - name: app\n releaseName: kapp\n"+ " valuesFile: values-prod.yaml\n");+ write_temp_file(tmp, "kz/values-prod.yaml", "image:\n tag: \"2.0\"\n");+ write_temp_file(tmp, "kz/charts/app/Chart.yaml", "apiVersion: v2\nname: app\nversion: 1.0.0\n");+ write_temp_file(tmp, "kz/charts/app/values.yaml",+ "image:\n repository: ghcr.io/acme/app\n tag: \"1.0\"\n");+ write_temp_file(tmp, "kz/charts/app/templates/deploy.yaml",+ "apiVersion: apps/v1\nkind: Deployment\nmetadata:\n name: app\nspec:\n"+ " template:\n spec:\n containers:\n - name: app\n"+ " image: \"{{ .Values.image.repository }}:{{ .Values.image.tag }}\"\n");+ char db_path[512];+ snprintf(db_path, sizeof(db_path), "%s/relvalues.db", tmp);+ static const char v2[] = "SELECT COUNT(*) FROM edges WHERE type='DEPLOYS' AND "+ "json_extract(properties,'$.image')='ghcr.io/acme/app:2.0'";+ static const char v3[] = "SELECT COUNT(*) FROM edges WHERE type='DEPLOYS' AND "+ "json_extract(properties,'$.image')='ghcr.io/acme/app:3.0'";+ int before = k8s_inc_index(tmp, db_path) == 0 ? k8s_inc_count(db_path, v2) : -1;+ write_temp_file(tmp, "kz/values-prod.yaml", "image:\n tag: \"3.0\"\n");+ int rc = k8s_inc_index(tmp, db_path);+ cbm_incremental_route_t route = cbm_pipeline_incremental_test_last_route();+ int stale = rc == 0 ? k8s_inc_count(db_path, v2) : -1;+ int after = rc == 0 ? k8s_inc_count(db_path, v3) : -1;+ th_rmtree(tmp);+ ASSERT_EQ(before, 1);+ ASSERT_EQ(route, CBM_INCREMENTAL_ROUTE_FORCED_FULL);+ ASSERT_EQ(stale, 0);+ ASSERT_EQ(after, 1);+ PASS();+}++/* Helm's values as its templates see them (helm_template.c): go-yaml v2+ * scalars -- YAML 1.1 booleans, every number a float64 printed like Go's %v+ * -- --set typing (int64, bool, null, a leading-zero string), coalesce where+ * a null deletes, and a field of a missing map an error: no value. */+TEST(helm_values_follow_helm_semantics) {+ yyjson_mut_doc *doc = yyjson_mut_doc_new(NULL);+ ASSERT_NOT_NULL(doc);+ static const char src[] = "tag: 1.10\nbig: 20231010\nm: 1000000\nyes_: yes\noff_: Off\n"+ "nul: ~\nq: \"1.10\"\noct: 0755\nkeep: k\ngone: g\n";+ yyjson_mut_val *v = cbm_helm_values_parse(doc, src, strlen(src));+ ASSERT_NOT_NULL(v);+ char buf[64];+ ASSERT_TRUE(cbm_helm_scalar_text(yyjson_mut_obj_get(v, "tag"), buf, sizeof(buf)));+ ASSERT_STR_EQ(buf, "1.1");+ ASSERT_TRUE(cbm_helm_scalar_text(yyjson_mut_obj_get(v, "big"), buf, sizeof(buf)));+ ASSERT_STR_EQ(buf, "2.023101e+07");+ ASSERT_TRUE(cbm_helm_scalar_text(yyjson_mut_obj_get(v, "m"), buf, sizeof(buf)));+ ASSERT_STR_EQ(buf, "1e+06");+ ASSERT_TRUE(cbm_helm_scalar_text(yyjson_mut_obj_get(v, "oct"), buf, sizeof(buf)));+ ASSERT_STR_EQ(buf, "493");+ ASSERT_TRUE(yyjson_mut_is_true(yyjson_mut_obj_get(v, "yes_")));+ ASSERT_TRUE(yyjson_mut_is_false(yyjson_mut_obj_get(v, "off_")));+ ASSERT_TRUE(yyjson_mut_is_null(yyjson_mut_obj_get(v, "nul")));+ ASSERT_STR_EQ(yyjson_mut_get_str(yyjson_mut_obj_get(v, "q")), "1.10");+ ASSERT_TRUE(cbm_helm_values_set(doc, v, "a\\.b.c[1]", "007", false));+ ASSERT_TRUE(cbm_helm_values_set(doc, v, "n", "42", false));+ ASSERT_TRUE(cbm_helm_values_set(doc, v, "s", "42", true));+ yyjson_mut_val *ab = yyjson_mut_obj_get(v, "a.b");+ ASSERT_NOT_NULL(ab);+ yyjson_mut_val *c = yyjson_mut_obj_get(ab, "c");+ ASSERT_TRUE(yyjson_mut_is_arr(c));+ ASSERT_TRUE(yyjson_mut_is_null(yyjson_mut_arr_get(c, 0)));+ ASSERT_STR_EQ(yyjson_mut_get_str(yyjson_mut_arr_get(c, 1)), "007");+ ASSERT_TRUE(yyjson_mut_is_int(yyjson_mut_obj_get(v, "n")));+ ASSERT_TRUE(yyjson_mut_is_str(yyjson_mut_obj_get(v, "s")));+ static const char over[] = "gone: null\nkeep: x\nnew: 1\n";+ yyjson_mut_val *o = cbm_helm_values_parse(doc, over, strlen(over));+ yyjson_mut_val *m = cbm_helm_values_coalesce(doc, v, o);+ ASSERT_NULL(yyjson_mut_obj_get(m, "gone"));+ ASSERT_STR_EQ(yyjson_mut_get_str(yyjson_mut_obj_get(m, "keep")), "x");+ ASSERT_NOT_NULL(yyjson_mut_obj_get(m, "new"));+ ASSERT_STR_EQ(yyjson_mut_get_str(yyjson_mut_obj_get(v, "keep")), "k"); /* base untouched */+ /* a template: a missing last key renders "", a field of it is an error */+ static const char tpl[] = "image: \"{{ .Values.keep }}:{{ .Values.none }}\"\n"+ "image: \"{{ .Values.none.repo }}\"\n";+ CBMArena a;+ cbm_arena_init_lazy(&a, CBM_SZ_4K);+ cbm_helm_probe_t probes[2] = {{.line = 1}, {.line = 2}};+ cbm_helm_render(&a, "t.yaml", tpl, strlen(tpl), v, NULL, NULL, probes, 2);+ ASSERT_EQ(probes[0].n, 1);+ ASSERT_STR_EQ(probes[0].image[0], "k:");+ ASSERT_EQ(probes[1].n, 1);+ ASSERT_NULL(probes[1].image[0]);+ cbm_arena_destroy(&a);+ yyjson_mut_doc_free(doc);+ PASS();+}+/* A compose project's .env feeds its compose file (variables in image,* build): changing it is no closure repair -- the unchanged compose file's* services would keep the old image. It rebuilds; no stale image remains. */@@ -23930,6 +24060,9 @@ SUITE(pipeline_semantic_manifest_repro) {RUN_TEST(incremental_env_edit_replaces_scoped_envvars);RUN_TEST(incremental_image_split_change_rebuilds);RUN_TEST(incremental_helm_values_edit_keeps_chart_edge);+ RUN_TEST(incremental_werf_values_edit_keeps_chart_edge);+ RUN_TEST(incremental_release_values_edit_rebuilds);+ RUN_TEST(helm_values_follow_helm_semantics);RUN_TEST(incremental_compose_dotenv_change_rebuilds);RUN_TEST(incremental_dockerfile_edit_keeps_docker_build_edges);RUN_TEST(incremental_second_build_declarer_keeps_the_edge);